Don't blend kernel and frontend CLI args

kernel args can be passed after `--`:

    ipython qtconsole -- --matplotlib inline

    ipython qtconsole --kernel julia -- --some-julia-flag

IPython/consoleapp.py

@@ -1,344 +1,330 b''
 """ 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/qt/console/qtconsoleapp.py
 """
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import atexit
 import os
 import signal
 import sys
 import uuid
 
 
 from IPython.config.application import boolean_flag
 from IPython.core.profiledir import ProfileDir
 from IPython.kernel.blocking import BlockingKernelClient
 from IPython.kernel import KernelManager
-from IPython.kernel import tunnel_to_kernel, find_connection_file, swallow_argv
+from IPython.kernel import tunnel_to_kernel, find_connection_file
 from IPython.kernel.kernelspec import NoSuchKernel
 from IPython.utils.path import filefind
 from IPython.utils.traitlets import (
     Dict, List, Unicode, CUnicode, CBool, Any
 )
-from IPython.kernel.zmq.kernelapp import (
-    kernel_flags,
-    kernel_aliases,
-    IPKernelApp
-)
-from IPython.kernel.zmq.pylab.config import InlineBackend
 from IPython.kernel.zmq.session import Session
-from IPython.kernel.zmq.zmqshell import ZMQInteractiveShell
 from IPython.kernel.connect import ConnectionFileMixin
 
 from IPython.utils.localinterfaces import localhost
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 
-flags = dict(kernel_flags)
+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' : ({'IPythonConsoleApp' : {'existing' : 'kernel*.json'}},
             "Connect to an existing kernel. If no argument specified, guess most recent"),
 }
 app_flags.update(boolean_flag(
     'confirm-exit', 'IPythonConsoleApp.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(kernel_aliases)
+aliases = {}
 
 # also scrub aliases from the frontend
 app_aliases = dict(
     ip = 'IPythonConsoleApp.ip',
     transport = 'IPythonConsoleApp.transport',
     hb = 'IPythonConsoleApp.hb_port',
     shell = 'IPythonConsoleApp.shell_port',
     iopub = 'IPythonConsoleApp.iopub_port',
     stdin = 'IPythonConsoleApp.stdin_port',
     existing = 'IPythonConsoleApp.existing',
     f = 'IPythonConsoleApp.connection_file',
 
     kernel = 'IPythonConsoleApp.kernel_name',
 
     ssh = 'IPythonConsoleApp.sshserver',
 )
 aliases.update(app_aliases)
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 classes = [KernelManager, ProfileDir, Session]
 
 class IPythonConsoleApp(ConnectionFileMixin):
     name = 'ipython-console-mixin'
 
     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 = classes
     flags = Dict(flags)
     aliases = Dict(aliases)
     kernel_manager_class = KernelManager
     kernel_client_class = BlockingKernelClient
 
     kernel_argv = List(Unicode)
     # frontend flags&aliases to be stripped when building kernel_argv
     frontend_flags = Any(app_flags)
     frontend_aliases = Any(app_aliases)
 
     # create requested profiles by default, if they don't exist:
     auto_create = CBool(True)
     # connection info:
     
     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.""")
     
     def _connection_file_default(self):
         return 'kernel-%i.json' % os.getpid()
 
     existing = CUnicode('', config=True,
         help="""Connect to an already running kernel""")
 
     kernel_name = Unicode('python', config=True,
         help="""The name of the default kernel to start.""")
 
     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.""",
     )
     
-    @property
-    def help_classes(self):
-        """ConsoleApps can configure kernels on the command-line
+    def build_kernel_argv(self, argv=None):
+        """build argv to be passed to kernel subprocess
         
-        But this shouldn't be written to a file
+        Override in subclasses if any args should be passed to the kernel
         """
-        return self.classes + [IPKernelApp] + IPKernelApp.classes
-    
-    def build_kernel_argv(self, argv=None):
-        """build argv to be passed to kernel subprocess"""
-        if argv is None:
-            argv = sys.argv[1:]
-        self.kernel_argv = swallow_argv(argv, self.frontend_aliases, self.frontend_flags)
+        self.kernel_argv = self.extra_args
     
     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.
         
         After this method is called, self.connection_file contains the *full path*
         to the connection file, never just its name.
         """
         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.debug("Connecting to existing kernel: %s" % cf)
             self.connection_file = cf
         else:
             # not existing, check if we are going to write the file
             # and ensure that self.connection_file is a full path, not just the shortname
             try:
                 cf = find_connection_file(self.connection_file)
             except Exception:
                 # 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(self.profile_dir.security_dir, self.connection_file)
                 else:
                     cf = self.connection_file
                 self.connection_file = cf
         try:
             self.connection_file = filefind(self.connection_file, ['.', self.profile_dir.security_dir])
         except IOError:
             self.log.debug("Connection File not found: %s", self.connection_file)
             return
         
         # 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 init_ssh(self):
         """set up ssh tunnels, if needed."""
         if not self.existing or (not self.sshserver and not self.sshkey):
             return
         self.load_connection_file()
         
         transport = self.transport
         ip = self.ip
         
         if transport != 'tcp':
             self.log.error("Can only use ssh tunnels with TCP sockets, not %s", transport)
             sys.exit(-1)
         
         if self.sshkey and not self.sshserver:
             # specifying just the key implies that we are connecting directly
             self.sshserver = ip
             ip = localhost()
         
         # build connection dict for tunnels:
         info = dict(ip=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"%(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.info("To connect another client via this tunnel, use:")
         self.log.info("--existing %s" % self.connection_file)
     
     def _new_connection_file(self):
         cf = ''
         while not cf:
             # we don't need a 128b id to distinguish kernels, use more readable
             # 48b node segment (12 hex chars).  Users running more than 32k simultaneous
             # kernels can subclass.
             ident = str(uuid.uuid4()).split('-')[-1]
             cf = os.path.join(self.profile_dir.security_dir, 'kernel-%s.json' % ident)
             # only keep if it's actually new.  Protect against unlikely collision
             # in 48b random search space
             cf = cf if not os.path.exists(cf) else ''
         return cf
 
     def init_kernel_manager(self):
         # Don't let Qt or ZMQ swallow KeyboardInterupts.
         if self.existing:
             self.kernel_manager = None
             return
         signal.signal(signal.SIGINT, signal.SIG_DFL)
 
         # Create a KernelManager and start a kernel.
         try:
             self.kernel_manager = self.kernel_manager_class(
                                     ip=self.ip,
                                     session=self.session,
                                     transport=self.transport,
                                     shell_port=self.shell_port,
                                     iopub_port=self.iopub_port,
                                     stdin_port=self.stdin_port,
                                     hb_port=self.hb_port,
                                     connection_file=self.connection_file,
                                     kernel_name=self.kernel_name,
                                     parent=self,
                                     ipython_dir=self.ipython_dir,
             )
         except NoSuchKernel:
             self.log.critical("Could not find kernel %s", self.kernel_name)
             self.exit(1)
 
         self.kernel_manager.client_factory = self.kernel_client_class
         # FIXME: remove special treatment of IPython kernels
         kwargs = {}
         if self.kernel_manager.ipython_kernel:
             kwargs['extra_arguments'] = self.kernel_argv
         self.kernel_manager.start_kernel(**kwargs)
         atexit.register(self.kernel_manager.cleanup_ipc_files)
 
         if self.sshserver:
             # ssh, write new connection file
             self.kernel_manager.write_connection_file()
 
         # in case KM defaults / ssh writing changes things:
         km = self.kernel_manager
         self.shell_port=km.shell_port
         self.iopub_port=km.iopub_port
         self.stdin_port=km.stdin_port
         self.hb_port=km.hb_port
         self.connection_file = km.connection_file
 
         atexit.register(self.kernel_manager.cleanup_connection_file)
 
     def init_kernel_client(self):
         if self.kernel_manager is not None:
             self.kernel_client = self.kernel_manager.client()
         else:
             self.kernel_client = self.kernel_client_class(
                                 session=self.session,
                                 ip=self.ip,
                                 transport=self.transport,
                                 shell_port=self.shell_port,
                                 iopub_port=self.iopub_port,
                                 stdin_port=self.stdin_port,
                                 hb_port=self.hb_port,
                                 connection_file=self.connection_file,
                                 parent=self,
             )
 
         self.kernel_client.start_channels()
 
 
 
     def initialize(self, argv=None):
         """
         Classes which mix this class in should call:
                IPythonConsoleApp.initialize(self,argv)
         """
         self.init_connection_file()
         self.init_ssh()
         self.init_kernel_manager()
         self.init_kernel_client()
 

IPython/terminal/ipapp.py

@@ -1,395 +1,380 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
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 from __future__ import absolute_import
 from __future__ import print_function
 
 import logging
 import os
 import sys
 
 from IPython.config.loader import Config
 from IPython.config.application import boolean_flag, catch_config_error, Application
 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.history import HistoryManager
 from IPython.core.prompts import PromptManager
 from IPython.core.application import (
     ProfileDir, BaseIPythonApplication, base_flags, base_aliases
 )
 from IPython.core.magics import ScriptMagics
 from IPython.core.shellapp import (
     InteractiveShellApp, shell_flags, shell_aliases
 )
 from IPython.extensions.storemagic import StoreMagics
 from IPython.terminal.interactiveshell import TerminalInteractiveShell
 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,
 )
 
 #-----------------------------------------------------------------------------
 # Globals, utilities and helpers
 #-----------------------------------------------------------------------------
 
 _examples = """
 ipython --matplotlib       # enable matplotlib integration
 ipython --matplotlib=qt    # enable matplotlib integration with 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 help qtconsole     # show the help for the qtconsole subcmd
 
 ipython console            # start the terminal-based console application
 ipython help console       # show the help for the console subcmd
 
 ipython notebook           # start the IPython notebook
 ipython help notebook      # show the help for the notebook subcmd
 
 ipython profile create foo # create profile foo w/ default config files
 ipython help profile       # show the help for the profile subcmd
 
 ipython locate             # print the path to the IPython directory
 ipython locate profile foo # print the path to the directory for profile `foo`
 
 ipython nbconvert           # convert notebooks to/from other formats
 """
 
 #-----------------------------------------------------------------------------
 # 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.author
         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)
 frontend_flags = {}
 addflag = lambda *args: frontend_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'
 
 frontend_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
 frontend_flags['quick']=(
     {'TerminalIPythonApp' : {'quick' : True}},
     "Enable quick startup with no config files."
 )
 
 frontend_flags['i'] = (
     {'TerminalIPythonApp' : {'force_interact' : True}},
     """If running code from the command line, become interactive afterwards."""
 )
 flags.update(frontend_flags)
 
 aliases = dict(base_aliases)
 aliases.update(shell_aliases)
 
 #-----------------------------------------------------------------------------
 # Main classes and functions
 #-----------------------------------------------------------------------------
 
 
 class LocateIPythonApp(BaseIPythonApplication):
     description = """print the path to the IPython dir"""
     subcommands = Dict(dict(
         profile=('IPython.core.profileapp.ProfileLocate',
             "print the path to an IPython profile directory",
         ),
     ))
     def start(self):
         if self.subapp is not None:
             return self.subapp.start()
         else:
             print(self.ipython_dir)
 
 
 class TerminalIPythonApp(BaseIPythonApplication, InteractiveShellApp):
     name = u'ipython'
     description = usage.cl_usage
     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,
             HistoryManager,
             ProfileDir,
             PlainTextFormatter,
             IPCompleter,
             ScriptMagics,
             StoreMagics,
         ]
 
     subcommands = dict(
         qtconsole=('IPython.qt.console.qtconsoleapp.IPythonQtConsoleApp',
             """Launch the IPython Qt Console."""
         ),
         notebook=('IPython.html.notebookapp.NotebookApp',
             """Launch the IPython HTML Notebook Server."""
         ),
         profile = ("IPython.core.profileapp.ProfileApp",
             "Create and manage IPython profiles."
         ),
         kernel = ("IPython.kernel.zmq.kernelapp.IPKernelApp",
             "Start a kernel without an attached frontend."
         ),
         console=('IPython.terminal.console.app.ZMQTerminalIPythonApp',
             """Launch the IPython terminal-based Console."""
         ),
         locate=('IPython.terminal.ipapp.LocateIPythonApp',
             LocateIPythonApp.description
         ),
         history=('IPython.core.historyapp.HistoryApp',
             "Manage the IPython history database."
         ),
         nbconvert=('IPython.nbconvert.nbconvertapp.NbConvertApp',
             "Convert notebooks to/from other formats."
         ),
         trust=('IPython.nbformat.sign.TrustNotebookApp',
             "Sign notebooks to trust their potentially unsafe contents at load."
         ),
         kernelspec=('IPython.kernel.kernelspecapp.KernelSpecApp',
             "Manage IPython kernel specifications."
         ),
     )
     subcommands['install-nbextension'] = (
         "IPython.html.nbextensions.NBExtensionApp",
         "Install IPython notebook extension files"
     )
 
     # *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
 
     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', start an interactive shell after executing the
         file or command."""
     )
     def _force_interact_changed(self, name, old, new):
         if new:
             self.interact = True
 
     def _file_to_run_changed(self, name, old, new):
         if new:
             self.something_to_run = True
         if new and not self.force_interact:
                 self.interact = False
     _code_to_run_changed = _file_to_run_changed
     _module_to_run_changed = _file_to_run_changed
 
     # internal, not-configurable
     interact=Bool(True)
     something_to_run=Bool(False)
 
     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 `--matplotlib <backend>` and import pylab manually.")
             argv[idx] = '--pylab'
 
         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 and not self.something_to_run:
             self.file_to_run = self.extra_args[0]
         self.init_path()
         # 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"""
         # 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(parent=self,
                         display_banner=False, profile_dir=self.profile_dir,
                         ipython_dir=self.ipython_dir, user_ns=self.user_ns)
         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 _pylab_changed(self, name, old, new):
         """Replace --pylab='inline' with --pylab='auto'"""
         if new == 'inline':
             warn.warn("'inline' not available as pylab backend, "
                       "using 'auto' instead.")
             self.pylab = 'auto'
 
     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')
 
     config = Config()
     for cf in Application._load_config_files("ipython_config", path=profile_dir):
         config.update(cf)
 
     return config
 
 launch_new_instance = TerminalIPythonApp.launch_instance
 
 
 if __name__ == '__main__':
     launch_new_instance()

jupyter_console/app.py

@@ -1,149 +1,145 b''
 """ 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
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
 import signal
 
 from IPython.terminal.ipapp import TerminalIPythonApp, frontend_flags as term_flags
 
 from IPython.utils.traitlets import (
     Dict, Any
 )
 from IPython.utils.warn import error
 
 from IPython.consoleapp import (
         IPythonConsoleApp, app_aliases, app_flags, aliases, flags
     )
 
 from IPython.terminal.console.interactiveshell import ZMQTerminalInteractiveShell
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 _examples = """
 ipython console # start the ZMQ-based console
 ipython console --existing # connect to an existing ipython session
 """
 
 #-----------------------------------------------------------------------------
 # Flags and Aliases
 #-----------------------------------------------------------------------------
 
 # copy flags from mixin:
 flags = dict(flags)
 # start with mixin frontend flags:
 frontend_flags = dict(app_flags)
 # add TerminalIPApp flags:
 frontend_flags.update(term_flags)
 # disable quick startup, as it won't propagate to the kernel anyway
 frontend_flags.pop('quick')
 # update full dict with frontend flags:
 flags.update(frontend_flags)
 
 # copy flags from mixin
 aliases = dict(aliases)
 # start with mixin frontend flags
 frontend_aliases = dict(app_aliases)
 # load updated frontend flags into full dict
 aliases.update(frontend_aliases)
 
 # get flags&aliases into sets, and remove a couple that
 # shouldn't be scrubbed from backend flags:
 frontend_aliases = set(frontend_aliases.keys())
 frontend_flags = set(frontend_flags.keys())
 
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 
 class ZMQTerminalIPythonApp(TerminalIPythonApp, IPythonConsoleApp):
     name = "ipython-console"
     """Start a terminal frontend to the IPython zmq kernel."""
 
     description = """
         The IPython terminal-based Console.
 
         This launches a Console application inside a terminal.
 
         The Console supports various extra features beyond the traditional
         single-process Terminal IPython shell, such as connecting to an
         existing ipython session, via:
 
             ipython console --existing
 
         where the previous session could have been created by another ipython
         console, an ipython qtconsole, or by opening an ipython notebook.
 
     """
     examples = _examples
 
     classes = [ZMQTerminalInteractiveShell] + IPythonConsoleApp.classes
     flags = Dict(flags)
     aliases = Dict(aliases)
     frontend_aliases = Any(frontend_aliases)
     frontend_flags = Any(frontend_flags)
     
     subcommands = Dict()
+    
+    force_interact = True
 
     def parse_command_line(self, argv=None):
         super(ZMQTerminalIPythonApp, self).parse_command_line(argv)
-        self.build_kernel_argv(argv)
+        self.build_kernel_argv(self.extra_args)
 
     def init_shell(self):
         IPythonConsoleApp.initialize(self)
         # relay sigint to kernel
         signal.signal(signal.SIGINT, self.handle_sigint)
         self.shell = ZMQTerminalInteractiveShell.instance(parent=self,
                         display_banner=False, profile_dir=self.profile_dir,
                         ipython_dir=self.ipython_dir,
                         manager=self.kernel_manager,
                         client=self.kernel_client,
         )
 
     def init_gui_pylab(self):
         # no-op, because we don't want to import matplotlib in the frontend.
         pass
 
     def handle_sigint(self, *args):
         if self.shell._executing:
             if self.kernel_manager:
                 # interrupt already gets passed to subprocess by signal handler.
                 # Only if we prevent that should we need to explicitly call
                 # interrupt_kernel, until which time, this would result in a 
                 # double-interrupt:
                 # self.kernel_manager.interrupt_kernel()
                 pass
             else:
                 self.shell.write_err('\n')
                 error("Cannot interrupt kernels we didn't start.\n")
         else:
             # raise the KeyboardInterrupt if we aren't waiting for execution,
             # so that the interact loop advances, and prompt is redrawn, etc.
             raise KeyboardInterrupt
             
 
     def init_code(self):
         # no-op in the frontend, code gets run in the backend
         pass
 
 
 launch_new_instance = ZMQTerminalIPythonApp.launch_instance
 
 
 if __name__ == '__main__':
     launch_new_instance()
 

jupyter_qtconsole/console/qtconsoleapp.py

@@ -1,386 +1,379 b''
 """ 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.
 """
 
 # Copyright (c) IPython Development Team.
-# Distributed under the terms of the Modified BSD License. 
+# Distributed under the terms of the Modified BSD License.
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-# stdlib imports
 import os
 import signal
 import sys
 
 # If run on Windows, install an exception hook which pops up a
 # message box. Pythonw.exe hides the console, so without this
 # the application silently fails to load.
 #
 # We always install this handler, because the expectation is for
 # qtconsole to bring up a GUI even if called from the console.
 # The old handler is called, so the exception is printed as well.
 # If desired, check for pythonw with an additional condition
 # (sys.executable.lower().find('pythonw.exe') >= 0).
 if os.name == 'nt':
     old_excepthook = sys.excepthook
 
     # Exclude this from our autogenerated API docs.
     undoc = lambda func: func
 
     @undoc
     def gui_excepthook(exctype, value, tb):
         try:
             import ctypes, traceback
             MB_ICONERROR = 0x00000010
             title = u'Error starting IPython QtConsole'
             msg = u''.join(traceback.format_exception(exctype, value, tb))
             ctypes.windll.user32.MessageBoxW(0, msg, title, MB_ICONERROR)
         finally:
             # Also call the old exception hook to let it do
             # its thing too.
             old_excepthook(exctype, value, tb)
 
     sys.excepthook = gui_excepthook
 
-# System library imports
 from IPython.external.qt import QtCore, QtGui
 
-# Local imports
 from IPython.config.application import boolean_flag
 from IPython.config.application import catch_config_error
 from IPython.core.application import BaseIPythonApplication
 from IPython.qt.console.ipython_widget import IPythonWidget
 from IPython.qt.console.rich_ipython_widget import RichIPythonWidget
 from IPython.qt.console import styles
 from IPython.qt.console.mainwindow import MainWindow
 from IPython.qt.client import QtKernelClient
 from IPython.qt.manager import QtKernelManager
 from IPython.utils.traitlets import (
     Dict, Unicode, CBool, Any
 )
 
 from IPython.consoleapp import (
         IPythonConsoleApp, app_aliases, app_flags, flags, aliases
     )
 
 #-----------------------------------------------------------------------------
 # Network Constants
 #-----------------------------------------------------------------------------
 
 from IPython.utils.localinterfaces import is_local_ip
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 _examples = """
 ipython qtconsole                      # start the qtconsole
 ipython qtconsole --matplotlib=inline  # start with matplotlib inline plotting mode
 """
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 
 # start with copy of flags
 flags = dict(flags)
 qt_flags = {
     'plain' : ({'IPythonQtConsoleApp' : {'plain' : True}},
             "Disable rich text support."),
 }
 qt_flags.update(boolean_flag(
     'banner', 'IPythonQtConsoleApp.display_banner',
     "Display a banner upon starting the QtConsole.",
     "Don't display a banner upon starting the QtConsole."
 ))
 
 # and app_flags from the Console Mixin
 qt_flags.update(app_flags)
 # add frontend flags to the full set
 flags.update(qt_flags)
 
 # start with copy of front&backend aliases list
 aliases = dict(aliases)
 qt_aliases = dict(
     style = 'IPythonWidget.syntax_style',
     stylesheet = 'IPythonQtConsoleApp.stylesheet',
     colors = 'ZMQInteractiveShell.colors',
 
     editor = 'IPythonWidget.editor',
     paging = 'ConsoleWidget.paging',
 )
 # and app_aliases from the Console Mixin
 qt_aliases.update(app_aliases)
 qt_aliases.update({'gui-completion':'ConsoleWidget.gui_completion'})
 # add frontend aliases to the full set
 aliases.update(qt_aliases)
 
 # get flags&aliases into sets, and remove a couple that
 # shouldn't be scrubbed from backend flags:
 qt_aliases = set(qt_aliases.keys())
 qt_aliases.remove('colors')
 qt_flags = set(qt_flags.keys())
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # IPythonQtConsole
 #-----------------------------------------------------------------------------
 
 
 class IPythonQtConsoleApp(BaseIPythonApplication, IPythonConsoleApp):
     name = 'ipython-qtconsole'
 
     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 --matplotlib=inline
         
         as well as saving your session as HTML, and printing the output.
         
     """
     examples = _examples
 
     classes = [IPythonWidget] + IPythonConsoleApp.classes
     flags = Dict(flags)
     aliases = Dict(aliases)
     frontend_flags = Any(qt_flags)
     frontend_aliases = Any(qt_aliases)
     kernel_client_class = QtKernelClient
     kernel_manager_class = QtKernelManager
 
     stylesheet = Unicode('', config=True,
         help="path to a custom CSS stylesheet")
 
     hide_menubar = CBool(False, config=True,
         help="Start the console window with the menu bar hidden.")
 
     maximize = CBool(False, config=True,
         help="Start the console window maximized.")
 
     plain = CBool(False, config=True,
         help="Use a plaintext widget instead of rich text (plain can't print/save).")
 
     display_banner = CBool(True, config=True,
         help="Whether to display a banner upon starting the QtConsole."
     )
 
     def _plain_changed(self, name, old, new):
         kind = 'plain' if new else 'rich'
         self.config.ConsoleWidget.kind = kind
         if new:
             self.widget_factory = IPythonWidget
         else:
             self.widget_factory = RichIPythonWidget
 
     # the factory for creating a widget
     widget_factory = Any(RichIPythonWidget)
 
     def parse_command_line(self, argv=None):
         super(IPythonQtConsoleApp, self).parse_command_line(argv)
-        self.build_kernel_argv(argv)
+        self.build_kernel_argv(self.extra_args)
 
 
     def new_frontend_master(self):
         """ Create and return new frontend attached to new kernel, launched on localhost.
         """
         kernel_manager = self.kernel_manager_class(
                                 connection_file=self._new_connection_file(),
                                 parent=self,
                                 autorestart=True,
         )
         # start the kernel
         kwargs = {}
         # FIXME: remove special treatment of IPython kernels
         if self.kernel_manager.ipython_kernel:
             kwargs['extra_arguments'] = self.kernel_argv
         kernel_manager.start_kernel(**kwargs)
         kernel_manager.client_factory = self.kernel_client_class
         kernel_client = kernel_manager.client()
         kernel_client.start_channels(shell=True, iopub=True)
         widget = self.widget_factory(config=self.config,
                                    local_kernel=True)
         self.init_colors(widget)
         widget.kernel_manager = kernel_manager
         widget.kernel_client = kernel_client
         widget._existing = False
         widget._may_close = True
         widget._confirm_exit = self.confirm_exit
         widget._display_banner = self.display_banner
         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_client = self.kernel_client_class(
                                 connection_file=current_widget.kernel_client.connection_file,
                                 config = self.config,
         )
         kernel_client.load_connection_file()
         kernel_client.start_channels()
         widget = self.widget_factory(config=self.config,
                                 local_kernel=False)
         self.init_colors(widget)
         widget._existing = True
         widget._may_close = False
         widget._confirm_exit = False
         widget._display_banner = self.display_banner
         widget.kernel_client = kernel_client
         widget.kernel_manager = current_widget.kernel_manager
         return widget
 
     def init_qt_app(self):
         # separate from qt_elements, because it must run first
         self.app = QtGui.QApplication([])
 
     def init_qt_elements(self):
         # Create the widget.
 
         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)
 
         ip = self.ip
         local_kernel = (not self.existing) or is_local_ip(ip)
         self.widget = self.widget_factory(config=self.config,
                                         local_kernel=local_kernel)
         self.init_colors(self.widget)
         self.widget._existing = self.existing
         self.widget._may_close = not self.existing
         self.widget._confirm_exit = self.confirm_exit
         self.widget._display_banner = self.display_banner
 
         self.widget.kernel_manager = self.kernel_manager
         self.widget.kernel_client = self.kernel_client
         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_magic_helper()
         self.window.init_menu_bar()
 
         # Ignore on OSX, where there is always a menu bar
         if sys.platform != 'darwin' and self.hide_menubar:
             self.window.menuBar().setVisible(False)
 
         self.window.setWindowTitle('IPython')
 
     def init_colors(self, widget):
         """Configure the coloring of the widget"""
         # Note: This will be dramatically simplified when colors
         # are removed from the backend.
 
         # parse the colors arg down to current known labels
         cfg = self.config
         colors = cfg.ZMQInteractiveShell.colors if 'ZMQInteractiveShell.colors' in cfg else None
         style = cfg.IPythonWidget.syntax_style if 'IPythonWidget.syntax_style' in cfg else None
         sheet = cfg.IPythonWidget.style_sheet if 'IPythonWidget.style_sheet' in cfg else 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
         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 dark/light/bw style
             widget.set_default_style(colors=colors)
 
         if self.stylesheet:
             # we got an explicit stylesheet
             if os.path.isfile(self.stylesheet):
                 with open(self.stylesheet) as f:
                     sheet = f.read()
             else:
                 raise IOError("Stylesheet %r not found." % self.stylesheet)
         if sheet:
             widget.style_sheet = sheet
             widget._style_sheet_changed()
             
 
     def init_signal(self):
         """allow clean shutdown on sigint"""
         signal.signal(signal.SIGINT, lambda sig, frame: self.exit(-2))
         # need a timer, so that QApplication doesn't block until a real
         # Qt event fires (can require mouse movement)
         # timer trick from http://stackoverflow.com/q/4938723/938949
         timer = QtCore.QTimer()
          # Let the interpreter run each 200 ms:
         timer.timeout.connect(lambda: None)
         timer.start(200)
         # hold onto ref, so the timer doesn't get cleaned up
         self._sigint_timer = timer
 
     @catch_config_error
     def initialize(self, argv=None):
         self.init_qt_app()
         super(IPythonQtConsoleApp, self).initialize(argv)
         IPythonConsoleApp.initialize(self,argv)
         self.init_qt_elements()
         self.init_signal()
 
     def start(self):
 
         # draw the window
         if self.maximize:
             self.window.showMaximized()
         else:
             self.window.show()
         self.window.raise_()
 
         # Start the application main loop.
         self.app.exec_()
 
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 def main():
     app = IPythonQtConsoleApp()
     app.initialize()
     app.start()
 
 
 if __name__ == '__main__':
     main()