Uploaded Test files

venv/Lib/site-packages/notebook/services/kernelspecs/handlers.py

@@ -0,0 +1,107 @@
+"""Tornado handlers for kernel specifications.
+
+Preliminary documentation at https://github.com/ipython/ipython/wiki/IPEP-25%3A-Registry-of-installed-kernels#rest-api
+"""
+
+# Copyright (c) Jupyter Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import glob
+import json
+import os
+pjoin = os.path.join
+
+from tornado import web, gen
+
+from ...base.handlers import APIHandler
+from ...utils import maybe_future, url_path_join, url_unescape
+
+
+
+def kernelspec_model(handler, name, spec_dict, resource_dir):
+    """Load a KernelSpec by name and return the REST API model"""
+    d = {
+        'name': name,
+        'spec': spec_dict,
+        'resources': {}
+    }
+
+    # Add resource files if they exist
+    resource_dir = resource_dir
+    for resource in ['kernel.js', 'kernel.css']:
+        if os.path.exists(pjoin(resource_dir, resource)):
+            d['resources'][resource] = url_path_join(
+                handler.base_url,
+                'kernelspecs',
+                name,
+                resource
+            )
+    for logo_file in glob.glob(pjoin(resource_dir, 'logo-*')):
+        fname = os.path.basename(logo_file)
+        no_ext, _ = os.path.splitext(fname)
+        d['resources'][no_ext] = url_path_join(
+            handler.base_url,
+            'kernelspecs',
+            name,
+            fname
+        )
+    return d
+
+
+def is_kernelspec_model(spec_dict):
+    """Returns True if spec_dict is already in proper form.  This will occur when using a gateway."""
+    return isinstance(spec_dict, dict) and 'name' in spec_dict and 'spec' in spec_dict and 'resources' in spec_dict
+
+
+class MainKernelSpecHandler(APIHandler):
+
+    @web.authenticated
+    @gen.coroutine
+    def get(self):
+        ksm = self.kernel_spec_manager
+        km = self.kernel_manager
+        model = {}
+        model['default'] = km.default_kernel_name
+        model['kernelspecs'] = specs = {}
+        kspecs = yield maybe_future(ksm.get_all_specs())
+        for kernel_name, kernel_info in kspecs.items():
+            try:
+                if is_kernelspec_model(kernel_info):
+                    d = kernel_info
+                else:
+                    d = kernelspec_model(self, kernel_name, kernel_info['spec'], kernel_info['resource_dir'])
+            except Exception:
+                self.log.error("Failed to load kernel spec: '%s'", kernel_name, exc_info=True)
+                continue
+            specs[kernel_name] = d
+        self.set_header("Content-Type", 'application/json')
+        self.finish(json.dumps(model))
+
+
+class KernelSpecHandler(APIHandler):
+
+    @web.authenticated
+    @gen.coroutine
+    def get(self, kernel_name):
+        ksm = self.kernel_spec_manager
+        kernel_name = url_unescape(kernel_name)
+        try:
+            spec = yield maybe_future(ksm.get_kernel_spec(kernel_name))
+        except KeyError as e:
+            raise web.HTTPError(404, u'Kernel spec %s not found' % kernel_name) from e
+        if is_kernelspec_model(spec):
+            model = spec
+        else:
+            model = kernelspec_model(self, kernel_name, spec.to_dict(), spec.resource_dir)
+        self.set_header("Content-Type", 'application/json')
+        self.finish(json.dumps(model))
+
+
+# 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),
+]

venv/Lib/site-packages/notebook/services/kernelspecs/tests/test_kernelspecs_api.py

@@ -0,0 +1,137 @@
+# coding: utf-8
+"""Test the kernel specs webservice API."""
+
+import errno
+import io
+import json
+import os
+import shutil
+
+pjoin = os.path.join
+
+import requests
+
+from jupyter_client.kernelspec import NATIVE_KERNEL_NAME
+from notebook.utils import url_path_join, url_escape
+from notebook.tests.launchnotebook import NotebookTestBase, assert_http_error
+
+# Copied from jupyter_client.tests.test_kernelspec so updating that doesn't
+# break these tests
+sample_kernel_json = {'argv':['cat', '{connection_file}'],
+                      'display_name':'Test kernel',
+                     }
+
+some_resource = u"The very model of a modern major general"
+
+
+class KernelSpecAPI(object):
+    """Wrapper for notebook API calls."""
+    def __init__(self, request):
+        self.request = request
+
+    def _req(self, verb, path, body=None):
+        response = self.request(verb,
+                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):
+        self.create_spec('sample')
+        self.create_spec('sample 2')
+        self.ks_api = KernelSpecAPI(self.request)
+
+    def create_spec(self, name):
+        sample_kernel_dir = pjoin(self.data_dir, 'kernels', name)
+        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)
+
+    def test_list_kernelspecs_bad(self):
+        """Can list kernelspecs when one is invalid"""
+        bad_kernel_dir = pjoin(self.data_dir, 'kernels', 'bad')
+        try:
+            os.makedirs(bad_kernel_dir)
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+        
+        with open(pjoin(bad_kernel_dir, 'kernel.json'), 'w') as f:
+            f.write("garbage")
+        
+        model = self.ks_api.list().json()
+        assert isinstance(model, dict)
+        self.assertEqual(model['default'], NATIVE_KERNEL_NAME)
+        specs = model['kernelspecs']
+        assert isinstance(specs, dict)
+        # 2: the sample kernelspec created in setUp, and the native Python kernel
+        self.assertGreaterEqual(len(specs), 2)
+        
+        shutil.rmtree(bad_kernel_dir)
+    
+    def test_list_kernelspecs(self):
+        model = self.ks_api.list().json()
+        assert isinstance(model, dict)
+        self.assertEqual(model['default'], NATIVE_KERNEL_NAME)
+        specs = model['kernelspecs']
+        assert isinstance(specs, dict)
+
+        # 2: the sample kernelspec created in setUp, and the native Python kernel
+        self.assertGreaterEqual(len(specs), 2)
+
+        def is_sample_kernelspec(s):
+            return s['name'] == 'sample' and s['spec']['display_name'] == 'Test kernel'
+
+        def is_default_kernelspec(s):
+            return s['name'] == NATIVE_KERNEL_NAME and s['spec']['display_name'].startswith("Python")
+
+        assert any(is_sample_kernelspec(s) for s in specs.values()), specs
+        assert any(is_default_kernelspec(s) for s in specs.values()), specs
+
+    def test_get_kernelspec(self):
+        model = self.ks_api.kernel_spec_info('Sample').json()  # Case insensitive
+        self.assertEqual(model['name'].lower(), 'sample')
+        self.assertIsInstance(model['spec'], dict)
+        self.assertEqual(model['spec']['display_name'], 'Test kernel')
+        self.assertIsInstance(model['resources'], dict)
+
+    def test_get_kernelspec_spaces(self):
+        model = self.ks_api.kernel_spec_info('sample%202').json()
+        self.assertEqual(model['name'].lower(), 'sample 2')
+
+    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')