Put full kernel info in REST API response for all kernels

IPython/html/services/kernelspecs/handlers.py

@@ -1,51 +1,52 b''
 """Tornado handlers for kernel specifications."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from tornado import web
 
 from zmq.utils import jsonapi
 
 from ...base.handlers import IPythonHandler, json_errors
 
 
 class MainKernelSpecHandler(IPythonHandler):
     SUPPORTED_METHODS = ('GET',)
 
     @web.authenticated
     @json_errors
     def get(self):
         ksm = self.kernel_spec_manager
         results = []
         for kernel_name in ksm.find_kernel_specs():
-            results.append(dict(name=kernel_name,
-                display_name=ksm.get_kernel_spec(kernel_name).display_name))
+            d = ksm.get_kernel_spec(kernel_name).to_dict()
+            d['name'] = kernel_name
+            results.append(d)
 
         self.set_header("Content-Type", 'application/json')
         self.finish(jsonapi.dumps(results))
 
 
 class KernelSpecHandler(IPythonHandler):
     SUPPORTED_METHODS = ('GET',)
 
     @web.authenticated
     @json_errors
     def get(self, kernel_name):
         ksm = self.kernel_spec_manager
         try:
             kernelspec = ksm.get_kernel_spec(kernel_name)
         except KeyError:
             raise web.HTTPError(404, u'Kernel spec %s not found' % kernel_name)
         self.set_header("Content-Type", 'application/json')
         self.finish(kernelspec.to_json())
 
 
 # URL to handler mappings
 
 kernel_name_regex = r"(?P<kernel_name>\w+)"
 
 default_handlers = [
     (r"/api/kernelspecs", MainKernelSpecHandler),
     (r"/api/kernelspecs/%s" % kernel_name_regex, KernelSpecHandler),
 ]

IPython/html/services/kernelspecs/tests/test_kernelspecs_api.py

@@ -1,94 +1,97 b''
 # coding: utf-8
 """Test the kernel specs webservice API."""
 
 import errno
 import io
 import json
 import os
 
 pjoin = os.path.join
 
 import requests
 
 from IPython.html.utils import url_path_join
 from IPython.html.tests.launchnotebook import NotebookTestBase, assert_http_error
 
 # Copied from IPython.kernel.tests.test_kernelspec so updating that doesn't
 # break these tests
 sample_kernel_json = {'argv':['cat', '{connection_file}'],
                       'display_name':'Test kernel',
                       'language':'bash',
                      }
 
 some_resource = u"The very model of a modern major general"
 
 
 class KernelSpecAPI(object):
     """Wrapper for notebook API calls."""
     def __init__(self, base_url):
         self.base_url = base_url
 
     def _req(self, verb, path, body=None):
         response = requests.request(verb,
                 url_path_join(self.base_url, path),
                 data=body,
         )
         response.raise_for_status()
         return response
 
     def list(self):
         return self._req('GET', 'api/kernelspecs')
 
     def kernel_spec_info(self, name):
         return self._req('GET', url_path_join('api/kernelspecs', name))
     
     def kernel_resource(self, name, path):
         return self._req('GET', url_path_join('kernelspecs', name, path))
 
 class APITest(NotebookTestBase):
     """Test the kernelspec web service API"""
     def setUp(self):
         ipydir = self.ipython_dir.name
         sample_kernel_dir = pjoin(ipydir, 'kernels', 'sample')
         try:
             os.makedirs(sample_kernel_dir)
         except OSError as e:
             if e.errno != errno.EEXIST:
                 raise
         
         with open(pjoin(sample_kernel_dir, 'kernel.json'), 'w') as f:
             json.dump(sample_kernel_json, f)
         
         with io.open(pjoin(sample_kernel_dir, 'resource.txt'), 'w',
                      encoding='utf-8') as f:
             f.write(some_resource)
 
         self.ks_api = KernelSpecAPI(self.base_url())
 
     def test_list_kernelspecs(self):
         specs = self.ks_api.list().json()
         assert isinstance(specs, list)
         
         # 2: the sample kernelspec created in setUp, and the native Python kernel
         self.assertEqual(len(specs), 2)
-        assert any(s == {'name': 'sample', 'display_name': 'Test kernel'}
-                    for s in specs), specs
+
+        def is_sample_kernelspec(s):
+            return s['name'] == 'sample' and s['display_name'] == 'Test kernel'
+
+        assert any(is_sample_kernelspec(s) for s in specs), specs
 
     def test_get_kernelspec(self):
         spec = self.ks_api.kernel_spec_info('Sample').json()  # Case insensitive
         self.assertEqual(spec['language'], 'bash')
 
     def test_get_nonexistant_kernelspec(self):
         with assert_http_error(404):
             self.ks_api.kernel_spec_info('nonexistant')
     
     def test_get_kernel_resource_file(self):
         res = self.ks_api.kernel_resource('sAmple', 'resource.txt')
         self.assertEqual(res.text, some_resource)
     
     def test_get_nonexistant_resource(self):
         with assert_http_error(404):
             self.ks_api.kernel_resource('nonexistant', 'resource.txt')
         
         with assert_http_error(404):
             self.ks_api.kernel_resource('sample', 'nonexistant.txt')

IPython/kernel/kernelspec.py

@@ -1,150 +1,153 b''
 import io
 import json
 import os
 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
 
 if os.name == 'nt':
     programdata = os.environ.get('PROGRAMDATA', None)
     if programdata:
         SYSTEM_KERNEL_DIR = pjoin(programdata, 'ipython', 'kernels')
     else:  # PROGRAMDATA is not defined by default on XP.
         SYSTEM_KERNEL_DIR = None
 else:
     SYSTEM_KERNEL_DIR = "/usr/share/ipython/kernels"
     
 NATIVE_KERNEL_NAME = 'python3' if PY3 else 'python2'
 
 class KernelSpec(HasTraits):
     argv = List()
     display_name = Unicode()
     language = Unicode()
     codemirror_mode = None
     env = Dict()
     
     resource_dir = Unicode()
     
     def __init__(self, resource_dir, argv, display_name, language,
                  codemirror_mode=None):
         super(KernelSpec, self).__init__(resource_dir=resource_dir, argv=argv,
                 display_name=display_name, language=language,
                 codemirror_mode=codemirror_mode)
         if not self.codemirror_mode:
             self.codemirror_mode = 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_json(self):
-        return json.dumps(dict(argv=self.argv,
+    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_DIR,
             self.user_kernel_dir,
         ]
 
     def _make_native_kernel_dir(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': 'Python 3' if PY3 else 'Python 2',
                        'language': 'python',
                        'codemirror_mode': {'name': 'python',
                                            'version': sys.version_info[0]},
                       },
                       f, indent=1)
         # TODO: Copy icons into directory
         return path
     
     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()
         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
         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 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)
  No newline at end of file