Merge pull request #6291 from takluyver/explicit-install-native-kernelspec

Make installation of native kernelspec explicit

docs/source/whatsnew/pr/incompat-kernelmanager-start-args

@@ -0,0 +1,2 b''
+- :meth:`~.KernelManager.start_kernel` and :meth:`~.KernelManager.format_kernel_cmd`
+  no longer accept a ``executable`` parameter. Use the kernelspec machinery instead.

IPython/kernel/kernelspec.py

@@ -1,196 +1,222 b''
 import io
 import json
 import os
 import shutil
 import sys
 
 pjoin = os.path.join
 
 from IPython.utils.path import get_ipython_dir
 from IPython.utils.py3compat import PY3
 from IPython.utils.traitlets import HasTraits, List, Unicode, Dict, Any
+from .launcher import make_ipkernel_cmd
 
 if os.name == 'nt':
     programdata = os.environ.get('PROGRAMDATA', None)
     if programdata:
         SYSTEM_KERNEL_DIRS = [pjoin(programdata, 'ipython', 'kernels')]
     else:  # PROGRAMDATA is not defined by default on XP.
         SYSTEM_KERNEL_DIRS = []
 else:
     SYSTEM_KERNEL_DIRS = ["/usr/share/ipython/kernels",
                           "/usr/local/share/ipython/kernels",
                          ]
     
 NATIVE_KERNEL_NAME = 'python3' if PY3 else 'python2'
 
 def _pythonfirst(s):
     "Sort key function that will put strings starting with 'python' first."
     if s == NATIVE_KERNEL_NAME:
         return '  ' + s  # Two spaces to sort this first of all
     elif s.startswith('python'):
         # Space is not valid in kernel names, so this should sort first
         return ' ' + s
     return s
 
 class KernelSpec(HasTraits):
     argv = List()
     display_name = Unicode()
     language = Unicode()
     codemirror_mode = Any() # can be unicode or dict
     env = Dict()
     resource_dir = Unicode()
     
     def _codemirror_mode_default(self):
         return self.language
     
     @classmethod
     def from_resource_dir(cls, resource_dir):
         """Create a KernelSpec object by reading kernel.json
         
         Pass the path to the *directory* containing kernel.json.
         """
         kernel_file = pjoin(resource_dir, 'kernel.json')
         with io.open(kernel_file, 'r', encoding='utf-8') as f:
             kernel_dict = json.load(f)
         return cls(resource_dir=resource_dir, **kernel_dict)
     
     def to_dict(self):
         return dict(argv=self.argv,
                     env=self.env,
                     display_name=self.display_name,
                     language=self.language,
                     codemirror_mode=self.codemirror_mode,
                    )
 
     def to_json(self):
         return json.dumps(self.to_dict())
 
 def _is_kernel_dir(path):
     """Is ``path`` a kernel directory?"""
     return os.path.isdir(path) and os.path.isfile(pjoin(path, 'kernel.json'))
 
 def _list_kernels_in(dir):
     """Return a mapping of kernel names to resource directories from dir.
     
     If dir is None or does not exist, returns an empty dict.
     """
     if dir is None or not os.path.isdir(dir):
         return {}
     return {f.lower(): pjoin(dir, f) for f in os.listdir(dir)
                         if _is_kernel_dir(pjoin(dir, f))}
 
 class NoSuchKernel(KeyError):
     def __init__(self, name):
         self.name = name
 
 class KernelSpecManager(HasTraits):
     ipython_dir = Unicode()
     def _ipython_dir_default(self):
         return get_ipython_dir()
 
     user_kernel_dir = Unicode()
     def _user_kernel_dir_default(self):
         return pjoin(self.ipython_dir, 'kernels')
     
     kernel_dirs = List(
         help="List of kernel directories to search. Later ones take priority over earlier."    
     )    
     def _kernel_dirs_default(self):
         return SYSTEM_KERNEL_DIRS + [
             self.user_kernel_dir,
         ]
 
-    def _make_native_kernel_dir(self):
+    @property
+    def _native_kernel_dict(self):
         """Makes a kernel directory for the native kernel.
         
         The native kernel is the kernel using the same Python runtime as this
         process. This will put its informatino in the user kernels directory.
         """
-        path = pjoin(self.user_kernel_dir, NATIVE_KERNEL_NAME)
-        os.makedirs(path, mode=0o755)
-        with open(pjoin(path, 'kernel.json'), 'w') as f:
-            json.dump({'argv':[NATIVE_KERNEL_NAME, '-c',
-                               'from IPython.kernel.zmq.kernelapp import main; main()',
-                                '-f', '{connection_file}'],
-                       'display_name': 'IPython (Python %d)' % (3 if PY3 else 2),
-                       'language': 'python',
-                       'codemirror_mode': {'name': 'ipython',
-                                           'version': sys.version_info[0]},
-                      },
-                      f, indent=1)
-        # TODO: Copy icons into directory
-        return path
-    
+        return {'argv':make_ipkernel_cmd(
+                       'from IPython.kernel.zmq.kernelapp import main; main()'),
+               'display_name': 'IPython (Python %d)' % (3 if PY3 else 2),
+               'language': 'python',
+               'codemirror_mode': {'name': 'ipython',
+                                   'version': sys.version_info[0]},
+              }
+
+    @property
+    def _native_kernel_resource_dir(self):
+        # TODO: This may be different when we actually have any resources
+        return os.path.dirname(__file__)
+
     def find_kernel_specs(self):
         """Returns a dict mapping kernel names to resource directories."""
         d = {}
         for kernel_dir in self.kernel_dirs:
             d.update(_list_kernels_in(kernel_dir))
-        
-        if NATIVE_KERNEL_NAME not in d:
-            d[NATIVE_KERNEL_NAME] = self._make_native_kernel_dir()
+
+        d[NATIVE_KERNEL_NAME] = self._native_kernel_resource_dir
         return d
         # TODO: Caching?
-    
+
     def get_kernel_spec(self, kernel_name):
         """Returns a :class:`KernelSpec` instance for the given kernel_name.
         
         Raises :exc:`NoSuchKernel` if the given kernel name is not found.
         """
-        if kernel_name == 'python':
-            kernel_name = NATIVE_KERNEL_NAME
+        if kernel_name in {'python', NATIVE_KERNEL_NAME}:
+            return KernelSpec(self._native_kernel_resource_dir, **self._native_kernel_dict)
+
         d = self.find_kernel_specs()
         try:
             resource_dir = d[kernel_name.lower()]
         except KeyError:
             raise NoSuchKernel(kernel_name)
         return KernelSpec.from_resource_dir(resource_dir)
+    
+    def _get_destination_dir(self, kernel_name, system=False):
+        if system:
+            if SYSTEM_KERNEL_DIRS:
+                return os.path.join(SYSTEM_KERNEL_DIRS[-1], kernel_name)
+            else:
+                raise EnvironmentError("No system kernel directory is available")
+        else:
+            return os.path.join(self.user_kernel_dir, kernel_name)
 
     def install_kernel_spec(self, source_dir, kernel_name=None, system=False,
                             replace=False):
         """Install a kernel spec by copying its directory.
         
         If ``kernel_name`` is not given, the basename of ``source_dir`` will
         be used.
         
         If ``system`` is True, it will attempt to install into the systemwide
         kernel registry. If the process does not have appropriate permissions,
         an :exc:`OSError` will be raised.
         
         If ``replace`` is True, this will replace an existing kernel of the same
         name. Otherwise, if the destination already exists, an :exc:`OSError`
         will be raised.
         """
         if not kernel_name:
             kernel_name = os.path.basename(source_dir)
         kernel_name = kernel_name.lower()
-
-        if system:
-            if SYSTEM_KERNEL_DIRS:
-                destination = os.path.join(SYSTEM_KERNEL_DIRS[-1], kernel_name)
-            else:
-                raise EnvironmentError("No system kernel directory is available")
-        else:
-            destination = os.path.join(self.user_kernel_dir, kernel_name)
+        
+        destination = self._get_destination_dir(kernel_name, system=system)
 
         if replace and os.path.isdir(destination):
             shutil.rmtree(destination)
 
         shutil.copytree(source_dir, destination)
 
+    def install_native_kernel_spec(self, system=False):
+        """Install the native kernel spec to the filesystem
+        
+        This allows a Python 3 frontend to use a Python 2 kernel, or vice versa.
+        The kernelspec will be written pointing to the Python executable on
+        which this is run.
+        
+        If ``system`` is True, it will attempt to install into the systemwide
+        kernel registry. If the process does not have appropriate permissions, 
+        an :exc:`OSError` will be raised.
+        """
+        path = self._get_destination_dir(NATIVE_KERNEL_NAME, system=system)
+        os.makedirs(path, mode=0o755)
+        with open(pjoin(path, 'kernel.json'), 'w') as f:
+            json.dump(self._native_kernel_dict, f, indent=1)
+        # TODO: Copy icons into directory
+        return path
+
 def find_kernel_specs():
     """Returns a dict mapping kernel names to resource directories."""
     return KernelSpecManager().find_kernel_specs()
 
 def get_kernel_spec(kernel_name):
     """Returns a :class:`KernelSpec` instance for the given kernel_name.
     
     Raises KeyError if the given kernel name is not found.
     """
     return KernelSpecManager().get_kernel_spec(kernel_name)
 
 def install_kernel_spec(source_dir, kernel_name=None, system=False, replace=False):
     return KernelSpecManager().install_kernel_spec(source_dir, kernel_name,
                                                     system, replace)
 
 install_kernel_spec.__doc__ = KernelSpecManager.install_kernel_spec.__doc__
+
+def install_native_kernel_spec(self, system=False):
+    return KernelSpecManager().install_native_kernel_spec(system=system)
+
+install_native_kernel_spec.__doc__ = KernelSpecManager.install_native_kernel_spec.__doc__

IPython/kernel/kernelspecapp.py

@@ -1,114 +1,145 b''
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import errno
 import os.path
 
 from IPython.config.application import Application
 from IPython.core.application import (
     BaseIPythonApplication, base_flags, base_aliases
 )
 from IPython.utils.traitlets import Instance, Dict, Unicode, Bool
 
 from .kernelspec import KernelSpecManager, _pythonfirst
 
 class ListKernelSpecs(BaseIPythonApplication):
     description = """List installed kernel specifications."""
     kernel_spec_manager = Instance(KernelSpecManager)
     
     # Not all of the base aliases are meaningful (e.g. profile)
     aliases = {k: base_aliases[k] for k in ['ipython-dir', 'log-level']}
     flags = {'debug': base_flags['debug'],}
 
     def _kernel_spec_manager_default(self):
         return KernelSpecManager(ipython_dir=self.ipython_dir)
 
     def start(self):
         print("Available kernels:")
         for kernelname in sorted(self.kernel_spec_manager.find_kernel_specs(),
                                  key=_pythonfirst):
             print("  %s" % kernelname)
 
 
 class InstallKernelSpec(BaseIPythonApplication):
     description = """Install a kernel specification directory."""
     kernel_spec_manager = Instance(KernelSpecManager)
 
     def _kernel_spec_manager_default(self):
         return KernelSpecManager(ipython_dir=self.ipython_dir)
 
     sourcedir = Unicode()
     kernel_name = Unicode("", config=True,
         help="Install the kernel spec with this name"
     )
     def _kernel_name_default(self):
         return os.path.basename(self.sourcedir)
 
     system = Bool(False, config=True,
         help="""
         Try to install the kernel spec to the systemwide directory instead of
         the per-user directory.
         """
     )
     replace = Bool(False, config=True,
         help="Replace any existing kernel spec with this name."
     )
 
     aliases = {'name': 'InstallKernelSpec.kernel_name'}
     for k in ['ipython-dir', 'log-level']:
         aliases[k] = base_aliases[k]
 
     flags = {'system': ({'InstallKernelSpec': {'system': True}},
                 "Install to the systemwide kernel registry"),
              'replace': ({'InstallKernelSpec': {'replace': True}},
                 "Replace any existing kernel spec with this name."),
              'debug': base_flags['debug'],
             }
 
     def parse_command_line(self, argv):
         super(InstallKernelSpec, self).parse_command_line(argv)
         # accept positional arg as profile name
         if self.extra_args:
             self.sourcedir = self.extra_args[0]
         else:
             print("No source directory specified.")
             self.exit(1)
 
     def start(self):
         try:
             self.kernel_spec_manager.install_kernel_spec(self.sourcedir,
                                                  kernel_name=self.kernel_name,
                                                  system=self.system,
                                                  replace=self.replace,
                                                 )
         except OSError as e:
             if e.errno == errno.EACCES:
                 print("Permission denied")
                 self.exit(1)
             elif e.errno == errno.EEXIST:
                 print("A kernel spec is already present at %s" % e.filename)
                 self.exit(1)
             raise
 
+class InstallNativeKernelSpec(BaseIPythonApplication):
+    description = """Install the native kernel spec directory for this Python."""
+    kernel_spec_manager = Instance(KernelSpecManager)
+
+    def _kernel_spec_manager_default(self):
+        return KernelSpecManager(ipython_dir=self.ipython_dir)
+
+    system = Bool(False, config=True,
+        help="""
+        Try to install the kernel spec to the systemwide directory instead of
+        the per-user directory.
+        """
+    )
+
+    # Not all of the base aliases are meaningful (e.g. profile)
+    aliases = {k: base_aliases[k] for k in ['ipython-dir', 'log-level']}
+    flags = {'system': ({'InstallOwnKernelSpec': {'system': True}},
+                "Install to the systemwide kernel registry"),
+             'debug': base_flags['debug'],
+            }
+
+    def start(self):
+        try:
+            self.kernel_spec_manager.install_native_kernel_spec(system=self.system)
+        except OSError as e:
+            if e.errno == errno.EACCES:
+                print("Permission denied")
+                self.exit(1)
+            raise
+
 class KernelSpecApp(Application):
     name = "ipython kernelspec"
     description = """Manage IPython kernel specifications."""
 
-    subcommands = Dict(dict(
-        list = (ListKernelSpecs, ListKernelSpecs.description.splitlines()[0]),
-        install = (InstallKernelSpec, InstallKernelSpec.description.splitlines()[0])
-    ))
-    
+    subcommands = Dict({
+        'list': (ListKernelSpecs, ListKernelSpecs.description.splitlines()[0]),
+        'install': (InstallKernelSpec, InstallKernelSpec.description.splitlines()[0]),
+        'install-self': (InstallNativeKernelSpec, InstallNativeKernelSpec.description.splitlines()[0]),
+    })
+
     aliases = {}
     flags = {}
 
     def start(self):
         if self.subapp is None:
             print("No subcommand specified. Must specify one of: %s"% list(self.subcommands))
             print()
             self.print_description()
             self.print_subcommands()
             self.exit(1)
         else:
             return self.subapp.start()

IPython/kernel/launcher.py

@@ -1,261 +1,258 b''
 """Utilities for launching kernels
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import os
 import sys
 from subprocess import Popen, PIPE
 
 from IPython.utils.encoding import getdefaultencoding
 from IPython.utils.py3compat import cast_bytes_py2
 
 
 def swallow_argv(argv, aliases=None, flags=None):
     """strip frontend-specific aliases and flags from an argument list
     
     For use primarily in frontend apps that want to pass a subset of command-line
     arguments through to a subprocess, where frontend-specific flags and aliases
     should be removed from the list.
     
     Parameters
     ----------
     
     argv : list(str)
         The starting argv, to be filtered
     aliases : container of aliases (dict, list, set, etc.)
         The frontend-specific aliases to be removed
     flags : container of flags (dict, list, set, etc.)
         The frontend-specific flags to be removed
     
     Returns
     -------
     
     argv : list(str)
         The argv list, excluding flags and aliases that have been stripped
     """
     
     if aliases is None:
         aliases = set()
     if flags is None:
         flags = set()
     
     stripped = list(argv) # copy
     
     swallow_next = False
     was_flag = False
     for a in argv:
         if a == '--':
             break
         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('-')):
                 stripped.remove(a)
                 continue
         if a.startswith('-'):
             split = a.lstrip('-').split('=')
             name = split[0]
             # we use startswith because argparse accepts any arg to be specified
             # by any leading section, as long as it is unique,
             # so `--no-br` means `--no-browser` in the notebook, etc.
             if any(alias.startswith(name) for alias in aliases):
                 stripped.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 = name in flags
             elif len(split) == 1 and any(flag.startswith(name) for flag in flags):
                 # strip flag, but don't swallow next, as flags don't take args
                 stripped.remove(a)
     
     # return shortened list
     return stripped
 
 
 def make_ipkernel_cmd(code, executable=None, extra_arguments=[], **kw):
     """Build Popen command list for launching an IPython kernel.
 
     Parameters
     ----------
     code : str,
         A string of Python code that imports and executes a kernel entry point.
 
     executable : str, optional (default sys.executable)
         The Python executable to use for the kernel process.
 
     extra_arguments : list, optional
         A list of extra arguments to pass when executing the launch code.
     
     Returns
     -------
     
     A Popen command list
     """
-    
-    # Build the kernel launch command.
     if executable is None:
         executable = sys.executable
     arguments = [ executable, '-c', code, '-f', '{connection_file}' ]
     arguments.extend(extra_arguments)
 
-    # Spawn a kernel.
     if sys.platform == 'win32':
 
         # If the kernel is running on pythonw and stdout/stderr are not been
         # re-directed, it will crash when more than 4KB of data is written to
         # stdout or stderr. This is a bug that has been with Python for a very
         # long time; see http://bugs.python.org/issue706263.
         # A cleaner solution to this problem would be to pass os.devnull to
         # Popen directly. Unfortunately, that does not work.
         if executable.endswith('pythonw.exe'):
             arguments.append('--no-stdout')
             arguments.append('--no-stderr')
 
     return arguments
 
 
 def launch_kernel(cmd, stdin=None, stdout=None, stderr=None, env=None,
                         independent=False,
                         cwd=None, ipython_kernel=True,
                         **kw
                         ):
     """ Launches a localhost kernel, binding to the specified ports.
 
     Parameters
     ----------
     cmd : Popen list,
         A string of Python code that imports and executes a kernel entry point.
 
     stdin, stdout, stderr : optional (default None)
         Standards streams, as defined in subprocess.Popen.
 
     independent : bool, optional (default False)
         If set, the kernel process is guaranteed to survive if this process
         dies. If not set, an effort is made to ensure that the kernel is killed
         when this process dies. Note that in this case it is still good practice
         to kill kernels manually before exiting.
 
     cwd : path, optional
         The working dir of the kernel process (default: cwd of this process).
 
     ipython_kernel : bool, optional
         Whether the kernel is an official IPython one,
         and should get a bit of special treatment.
 
     Returns
     -------
     
     Popen instance for the kernel subprocess
     """
 
     # Popen will fail (sometimes with a deadlock) if stdin, stdout, and stderr
     # are invalid. Unfortunately, there is in general no way to detect whether
     # they are valid.  The following two blocks redirect them to (temporary)
     # pipes in certain important cases.
 
     # If this process has been backgrounded, our stdin is invalid. Since there
     # is no compelling reason for the kernel to inherit our stdin anyway, we'll
     # place this one safe and always redirect.
     redirect_in = True
     _stdin = PIPE if stdin is None else stdin
 
     # If this process in running on pythonw, we know that stdin, stdout, and
     # stderr are all invalid.
     redirect_out = sys.executable.endswith('pythonw.exe')
     if redirect_out:
         _stdout = PIPE if stdout is None else stdout
         _stderr = PIPE if stderr is None else stderr
     else:
         _stdout, _stderr = stdout, stderr
     
     env = env if (env is not None) else os.environ.copy()
 
     encoding = getdefaultencoding(prefer_stream=False)
     
     # Spawn a kernel.
     if sys.platform == 'win32':
         # Popen on Python 2 on Windows cannot handle unicode args or cwd
         cmd = [ cast_bytes_py2(c, encoding) for c in cmd ]
         if cwd:
             cwd = cast_bytes_py2(cwd, sys.getfilesystemencoding() or 'ascii')
         
         from IPython.kernel.zmq.parentpoller import ParentPollerWindows
         # Create a Win32 event for interrupting the kernel.
         interrupt_event = ParentPollerWindows.create_interrupt_event()
         # Store this in an environment variable for third party kernels, but at
         # present, our own kernel expects this as a command line argument.
         env["IPY_INTERRUPT_EVENT"] = str(interrupt_event)
         if ipython_kernel:
             cmd += [ '--interrupt=%i' % interrupt_event ]
 
             # If the kernel is running on pythonw and stdout/stderr are not been
             # re-directed, it will crash when more than 4KB of data is written to
             # stdout or stderr. This is a bug that has been with Python for a very
             # long time; see http://bugs.python.org/issue706263.
             # A cleaner solution to this problem would be to pass os.devnull to
             # Popen directly. Unfortunately, that does not work.
             if cmd[0].endswith('pythonw.exe'):
                 if stdout is None:
                     cmd.append('--no-stdout')
                 if stderr is None:
                     cmd.append('--no-stderr')
 
         # Launch the kernel process.
         if independent:
             proc = Popen(cmd,
                          creationflags=512, # CREATE_NEW_PROCESS_GROUP
                          stdin=_stdin, stdout=_stdout, stderr=_stderr, env=env)
         else:
             if ipython_kernel:
                 try:
                     from _winapi import DuplicateHandle, GetCurrentProcess, \
                         DUPLICATE_SAME_ACCESS
                 except:
                     from _subprocess import DuplicateHandle, GetCurrentProcess, \
                         DUPLICATE_SAME_ACCESS
                 pid = GetCurrentProcess()
                 handle = DuplicateHandle(pid, pid, pid, 0,
                                          True, # Inheritable by new processes.
                                          DUPLICATE_SAME_ACCESS)
                 cmd +=[ '--parent=%i' % handle ]
             
             
             proc = Popen(cmd,
                          stdin=_stdin, stdout=_stdout, stderr=_stderr, cwd=cwd, env=env)
 
         # Attach the interrupt event to the Popen objet so it can be used later.
         proc.win32_interrupt_event = interrupt_event
 
     else:
         if independent:
             proc = Popen(cmd, preexec_fn=lambda: os.setsid(),
                          stdin=_stdin, stdout=_stdout, stderr=_stderr, cwd=cwd, env=env)
         else:
             if ipython_kernel:
                 cmd += ['--parent=1']
             proc = Popen(cmd,
                          stdin=_stdin, stdout=_stdout, stderr=_stderr, cwd=cwd, env=env)
 
     # Clean up pipes created to work around Popen bug.
     if redirect_in:
         if stdin is None:
             proc.stdin.close()
     if redirect_out:
         if stdout is None:
             proc.stdout.close()
         if stderr is None:
             proc.stderr.close()
 
     return proc
 
 __all__ = [
     'swallow_argv',
     'make_ipkernel_cmd',
     'launch_kernel',
 ]

IPython/kernel/manager.py

@@ -1,416 +1,412 b''
 """Base class to manage a running kernel"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from __future__ import absolute_import
 
 import os
 import re
 import signal
 import sys
 import time
 import warnings
 
 import zmq
 
 from IPython.utils.importstring import import_item
 from IPython.utils.localinterfaces import is_local_ip, local_ips
 from IPython.utils.path import get_ipython_dir
 from IPython.utils.traitlets import (
     Any, Instance, Unicode, List, Bool, Type, DottedObjectName
 )
 from IPython.kernel import (
     make_ipkernel_cmd,
     launch_kernel,
     kernelspec,
 )
 from .connect import ConnectionFileMixin
 from .zmq.session import Session
 from .managerabc import (
     KernelManagerABC
 )
 
 
 class KernelManager(ConnectionFileMixin):
     """Manages a single kernel in a subprocess on this host.
 
     This version starts kernels with Popen.
     """
 
     # The PyZMQ Context to use for communication with the kernel.
     context = Instance(zmq.Context)
     def _context_default(self):
         return zmq.Context.instance()
 
     # the class to create with our `client` method
     client_class = DottedObjectName('IPython.kernel.blocking.BlockingKernelClient')
     client_factory = Type()
     def _client_class_changed(self, name, old, new):
         self.client_factory = import_item(str(new))
 
     # The kernel process with which the KernelManager is communicating.
     # generally a Popen instance
     kernel = Any()
     
     kernel_spec_manager = Instance(kernelspec.KernelSpecManager)
     
     def _kernel_spec_manager_default(self):
         return kernelspec.KernelSpecManager(ipython_dir=self.ipython_dir)
     
     kernel_name = Unicode(kernelspec.NATIVE_KERNEL_NAME)
     
     kernel_spec = Instance(kernelspec.KernelSpec)
     
     def _kernel_spec_default(self):
         return self.kernel_spec_manager.get_kernel_spec(self.kernel_name)
     
     def _kernel_name_changed(self, name, old, new):
         if new == 'python':
             self.kernel_name = kernelspec.NATIVE_KERNEL_NAME
             # This triggered another run of this function, so we can exit now
             return
         self.kernel_spec = self.kernel_spec_manager.get_kernel_spec(new)
         self.ipython_kernel = new in {'python', 'python2', 'python3'}
 
     kernel_cmd = List(Unicode, config=True,
         help="""DEPRECATED: Use kernel_name instead.
         
         The Popen Command to launch the kernel.
         Override this if you have a custom kernel.
         If kernel_cmd is specified in a configuration file,
         IPython does not pass any arguments to the kernel,
         because it cannot make any assumptions about the 
         arguments that the kernel understands. In particular,
         this means that the kernel does not receive the
         option --debug if it given on the IPython command line.
         """
     )
 
     def _kernel_cmd_changed(self, name, old, new):
         warnings.warn("Setting kernel_cmd is deprecated, use kernel_spec to "
                       "start different kernels.")
         self.ipython_kernel = False
 
     ipython_kernel = Bool(True)
     
     ipython_dir = Unicode()
     def _ipython_dir_default(self):
         return get_ipython_dir()
 
     # Protected traits
     _launch_args = Any()
     _control_socket = Any()
 
     _restarter = Any()
 
     autorestart = Bool(False, config=True,
         help="""Should we autorestart the kernel if it dies."""
     )
 
     def __del__(self):
         self._close_control_socket()
         self.cleanup_connection_file()
 
     #--------------------------------------------------------------------------
     # Kernel restarter
     #--------------------------------------------------------------------------
 
     def start_restarter(self):
         pass
 
     def stop_restarter(self):
         pass
 
     def add_restart_callback(self, callback, event='restart'):
         """register a callback to be called when a kernel is restarted"""
         if self._restarter is None:
             return
         self._restarter.add_callback(callback, event)
 
     def remove_restart_callback(self, callback, event='restart'):
         """unregister a callback to be called when a kernel is restarted"""
         if self._restarter is None:
             return
         self._restarter.remove_callback(callback, event)
 
     #--------------------------------------------------------------------------
     # create a Client connected to our Kernel
     #--------------------------------------------------------------------------
 
     def client(self, **kwargs):
         """Create a client configured to connect to our kernel"""
         if self.client_factory is None:
             self.client_factory = import_item(self.client_class)
 
         kw = {}
         kw.update(self.get_connection_info())
         kw.update(dict(
             connection_file=self.connection_file,
             session=self.session,
             parent=self,
         ))
 
         # add kwargs last, for manual overrides
         kw.update(kwargs)
         return self.client_factory(**kw)
 
     #--------------------------------------------------------------------------
     # Kernel management
     #--------------------------------------------------------------------------
 
-    def format_kernel_cmd(self, **kw):
+    def format_kernel_cmd(self, extra_arguments=None):
         """replace templated args (e.g. {connection_file})"""
+        extra_arguments = extra_arguments or []
         if self.kernel_cmd:
-            cmd = self.kernel_cmd
-        elif self.kernel_name == kernelspec.NATIVE_KERNEL_NAME:
-            # The native kernel gets special handling
-            cmd = make_ipkernel_cmd(
-                'from IPython.kernel.zmq.kernelapp import main; main()',
-                **kw
-            )
+            cmd = self.kernel_cmd + extra_arguments
         else:
-            cmd = self.kernel_spec.argv
+            cmd = self.kernel_spec.argv + extra_arguments
 
         ns = dict(connection_file=self.connection_file)
         ns.update(self._launch_args)
         
         pat = re.compile(r'\{([A-Za-z0-9_]+)\}')
         def from_ns(match):
             """Get the key out of ns if it's there, otherwise no change."""
             return ns.get(match.group(1), match.group())
         
         return [ pat.sub(from_ns, arg) for arg in cmd ]
 
     def _launch_kernel(self, kernel_cmd, **kw):
         """actually launch the kernel
 
         override in a subclass to launch kernel subprocesses differently
         """
         return launch_kernel(kernel_cmd, **kw)
 
     # Control socket used for polite kernel shutdown
 
     def _connect_control_socket(self):
         if self._control_socket is None:
             self._control_socket = self.connect_control()
             self._control_socket.linger = 100
 
     def _close_control_socket(self):
         if self._control_socket is None:
             return
         self._control_socket.close()
         self._control_socket = None
 
     def start_kernel(self, **kw):
         """Starts a kernel on this host in a separate process.
 
         If random ports (port=0) are being used, this method must be called
         before the channels are created.
 
         Parameters
         ----------
         **kw : optional
              keyword arguments that are passed down to build the kernel_cmd
              and launching the kernel (e.g. Popen kwargs).
         """
         if self.transport == 'tcp' and not is_local_ip(self.ip):
             raise RuntimeError("Can only launch a kernel on a local interface. "
                                "Make sure that the '*_address' attributes are "
                                "configured properly. "
                                "Currently valid addresses are: %s" % local_ips()
                                )
 
         # write connection file / get default ports
         self.write_connection_file()
 
         # save kwargs for use in restart
         self._launch_args = kw.copy()
         # build the Popen cmd
-        kernel_cmd = self.format_kernel_cmd(**kw)
+        extra_arguments = kw.pop('extra_arguments', [])
+        kernel_cmd = self.format_kernel_cmd(extra_arguments=extra_arguments)
         if self.kernel_cmd:
             # If kernel_cmd has been set manually, don't refer to a kernel spec
             env = os.environ
         else:
             # Environment variables from kernel spec are added to os.environ
             env = os.environ.copy()
             env.update(self.kernel_spec.env or {})
         # launch the kernel subprocess
         self.kernel = self._launch_kernel(kernel_cmd, env=env,
                                     ipython_kernel=self.ipython_kernel,
                                     **kw)
         self.start_restarter()
         self._connect_control_socket()
 
     def request_shutdown(self, restart=False):
         """Send a shutdown request via control channel
         
         On Windows, this just kills kernels instead, because the shutdown
         messages don't work.
         """
         content = dict(restart=restart)
         msg = self.session.msg("shutdown_request", content=content)
         self.session.send(self._control_socket, msg)
 
     def finish_shutdown(self, waittime=1, pollinterval=0.1):
         """Wait for kernel shutdown, then kill process if it doesn't shutdown.
         
         This does not send shutdown requests - use :meth:`request_shutdown`
         first.
         """
         for i in range(int(waittime/pollinterval)):
             if self.is_alive():
                 time.sleep(pollinterval)
             else:
                 break
         else:
             # OK, we've waited long enough.
             if self.has_kernel:
                 self._kill_kernel()
 
     def cleanup(self, connection_file=True):
         """Clean up resources when the kernel is shut down"""
         if connection_file:
             self.cleanup_connection_file()
 
         self.cleanup_ipc_files()
         self._close_control_socket()
 
     def shutdown_kernel(self, now=False, restart=False):
         """Attempts to the stop the kernel process cleanly.
 
         This attempts to shutdown the kernels cleanly by:
 
         1. Sending it a shutdown message over the shell channel.
         2. If that fails, the kernel is shutdown forcibly by sending it
            a signal.
 
         Parameters
         ----------
         now : bool
             Should the kernel be forcible killed *now*. This skips the
             first, nice shutdown attempt.
         restart: bool
             Will this kernel be restarted after it is shutdown. When this
             is True, connection files will not be cleaned up.
         """
         # Stop monitoring for restarting while we shutdown.
         self.stop_restarter()
 
         if now:
             self._kill_kernel()
         else:
             self.request_shutdown(restart=restart)
             # Don't send any additional kernel kill messages immediately, to give
             # the kernel a chance to properly execute shutdown actions. Wait for at
             # most 1s, checking every 0.1s.
             self.finish_shutdown()
 
         self.cleanup(connection_file=not restart)
 
     def restart_kernel(self, now=False, **kw):
         """Restarts a kernel with the arguments that were used to launch it.
 
         If the old kernel was launched with random ports, the same ports will be
         used for the new kernel. The same connection file is used again.
 
         Parameters
         ----------
         now : bool, optional
             If True, the kernel is forcefully restarted *immediately*, without
             having a chance to do any cleanup action.  Otherwise the kernel is
             given 1s to clean up before a forceful restart is issued.
 
             In all cases the kernel is restarted, the only difference is whether
             it is given a chance to perform a clean shutdown or not.
 
         **kw : optional
             Any options specified here will overwrite those used to launch the
             kernel.
         """
         if self._launch_args is None:
             raise RuntimeError("Cannot restart the kernel. "
                                "No previous call to 'start_kernel'.")
         else:
             # Stop currently running kernel.
             self.shutdown_kernel(now=now, restart=True)
 
             # Start new kernel.
             self._launch_args.update(kw)
             self.start_kernel(**self._launch_args)
 
     @property
     def has_kernel(self):
         """Has a kernel been started that we are managing."""
         return self.kernel is not None
 
     def _kill_kernel(self):
         """Kill the running kernel.
 
         This is a private method, callers should use shutdown_kernel(now=True).
         """
         if self.has_kernel:
 
             # Signal the kernel to terminate (sends SIGKILL on Unix and calls
             # TerminateProcess() on Win32).
             try:
                 self.kernel.kill()
             except OSError as e:
                 # In Windows, we will get an Access Denied error if the process
                 # has already terminated. Ignore it.
                 if sys.platform == 'win32':
                     if e.winerror != 5:
                         raise
                 # On Unix, we may get an ESRCH error if the process has already
                 # terminated. Ignore it.
                 else:
                     from errno import ESRCH
                     if e.errno != ESRCH:
                         raise
 
             # Block until the kernel terminates.
             self.kernel.wait()
             self.kernel = None
         else:
             raise RuntimeError("Cannot kill kernel. No kernel is running!")
 
     def interrupt_kernel(self):
         """Interrupts the kernel by sending it a signal.
 
         Unlike ``signal_kernel``, this operation is well supported on all
         platforms.
         """
         if self.has_kernel:
             if sys.platform == 'win32':
                 from .zmq.parentpoller import ParentPollerWindows as Poller
                 Poller.send_interrupt(self.kernel.win32_interrupt_event)
             else:
                 self.kernel.send_signal(signal.SIGINT)
         else:
             raise RuntimeError("Cannot interrupt kernel. No kernel is running!")
 
     def signal_kernel(self, signum):
         """Sends a signal to the kernel.
 
         Note that since only SIGTERM is supported on Windows, this function is
         only useful on Unix systems.
         """
         if self.has_kernel:
             self.kernel.send_signal(signum)
         else:
             raise RuntimeError("Cannot signal kernel. No kernel is running!")
 
     def is_alive(self):
         """Is the kernel process still running?"""
         if self.has_kernel:
             if self.kernel.poll() is None:
                 return True
             else:
                 return False
         else:
             # we don't have a kernel
             return False
 
 
 KernelManagerABC.register(KernelManager)