Make installation of native kernelspec explicit

Instead of creating a kernelspec directory matching the running
frontend, return its spec without writing to disk.

Adds a command 'ipython kernelspec install-self' to write a kernelspec
for the current version of Python.

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
 
 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',
+        return {'argv':[sys.executable, '-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
+              }
+
+    @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__
  No newline at end of file

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()