require Python 3.5

3.4 doesn't have isawaitable

remove unsupported combinations from test matrix

Author: minrk

.travis.yml

@@ -68,10 +68,6 @@ matrix:
           dist: xenial  # required for Python >= 3.7 (travis-ci/travis-ci#9069)
         - python: 3.6
           env: GROUP=docs
-        - python: 3.6
-          env:
-          - GROUP=python
-          - EXTRA_PIP="tornado<5"
 
 after_success:
     - codecov

jupyter_server/files/handlers.py

@@ -6,16 +6,11 @@
 import mimetypes
 import json
 from base64 import decodebytes
-
-from base64 import decodebytes
-
 from tornado import gen, web
-
 from jupyter_server.base.handlers import JupyterHandler
 from jupyter_server.utils import maybe_future
 
 
-
 class FilesHandler(JupyterHandler):
     """serve files via ContentsManager
 

jupyter_server/services/kernelspecs/handlers.py

@@ -11,7 +11,7 @@
 import os
 pjoin = os.path.join
 
-from tornado import web
+from tornado import web, gen
 
 from ...base.handlers import APIHandler
 from ...utils import maybe_future, url_path_join, url_unescape
@@ -49,6 +49,7 @@ def kernelspec_model(handler, name, spec_dict, resource_dir):
 class MainKernelSpecHandler(APIHandler):
 
     @web.authenticated
+    @gen.coroutine
     def get(self):
         ksm = self.kernel_spec_manager
         km = self.kernel_manager
@@ -71,6 +72,7 @@ def get(self):
 class KernelSpecHandler(APIHandler):
 
     @web.authenticated
+    @gen.coroutine
     def get(self, kernel_name):
         ksm = self.kernel_spec_manager
         kernel_name = url_unescape(kernel_name)

jupyter_server/services/sessions/sessionmanager.py

@@ -24,18 +24,18 @@ class SessionManager(LoggingConfigurable):
 
     kernel_manager = Instance('jupyter_server.services.kernels.kernelmanager.MappingKernelManager')
     contents_manager = Instance('jupyter_server.services.contents.manager.ContentsManager')
-
+    
     # Session database initialized below
     _cursor = None
     _connection = None
     _columns = {'session_id', 'path', 'name', 'type', 'kernel_id'}
-
+    
     @property
     def cursor(self):
         """Start a cursor and create a database called 'session'"""
         if self._cursor is None:
             self._cursor = self.connection.cursor()
-            self._cursor.execute("""CREATE TABLE session
+            self._cursor.execute("""CREATE TABLE session 
                 (session_id, path, name, type, kernel_id)""")
         return self._cursor
 
@@ -46,7 +46,7 @@ def connection(self):
             self._connection = sqlite3.connect(':memory:')
             self._connection.row_factory = sqlite3.Row
         return self._connection
-
+    
     def close(self):
         """Close the sqlite connection"""
         if self._cursor is not None:
@@ -57,13 +57,13 @@ def __del__(self):
         """Close connection once SessionManager closes"""
         self.close()
 
+    @gen.coroutine
     def session_exists(self, path):
         """Check to see if the session of a given name exists"""
+        exists = False
         self.cursor.execute("SELECT * FROM session WHERE path=?", (path,))
         row = self.cursor.fetchone()
-        if row is None:
-            return False
-        else:
+        if row is not None:
             # Note, although we found a row for the session, the associated kernel may have
             # been culled or died unexpectedly.  If that's the case, we should delete the
             # row, thereby terminating the session.  This can be done via a call to
@@ -103,13 +103,14 @@ def start_kernel_for_session(self, session_id, path, name, type, kernel_name):
         # py2-compat
         raise gen.Return(kernel_id)
 
+    @gen.coroutine
     def save_session(self, session_id, path=None, name=None, type=None, kernel_id=None):
         """Saves the items for the session with the given session_id
-
+        
         Given a session_id (and any other of the arguments), this method
         creates a row in the sqlite session database that holds the information
         for a session.
-
+        
         Parameters
         ----------
         session_id : str
@@ -122,7 +123,7 @@ def save_session(self, session_id, path=None, name=None, type=None, kernel_id=No
             the type of the session
         kernel_id : str
             a uuid for the kernel associated with this session
-
+        
         Returns
         -------
         model : dict
@@ -134,9 +135,10 @@ def save_session(self, session_id, path=None, name=None, type=None, kernel_id=No
         result = yield maybe_future(self.get_session(session_id=session_id))
         raise gen.Return(result)
 
+    @gen.coroutine
     def get_session(self, **kwargs):
         """Returns the model for a particular session.
-
+        
         Takes a keyword argument and searches for the value in the session
         database, then returns the rest of the session's info.
 
@@ -149,7 +151,7 @@ def get_session(self, **kwargs):
         Returns
         -------
         model : dict
-            returns a dictionary that includes all the information from the
+            returns a dictionary that includes all the information from the 
             session described by the kwarg.
         """
         if not kwargs:
@@ -180,19 +182,20 @@ def get_session(self, **kwargs):
         model = yield maybe_future(self.row_to_model(row))
         raise gen.Return(model)
 
+    @gen.coroutine
     def update_session(self, session_id, **kwargs):
         """Updates the values in the session database.
-
+        
         Changes the values of the session with the given session_id
-        with the values from the keyword arguments.
-
+        with the values from the keyword arguments. 
+        
         Parameters
         ----------
         session_id : str
             a uuid that identifies a session in the sqlite3 database
         **kwargs : str
             the key must correspond to a column title in session database,
-            and the value replaces the current value in the session
+            and the value replaces the current value in the session 
             with session_id.
         """
         yield maybe_future(self.get_session(session_id=session_id))
@@ -209,6 +212,11 @@ def update_session(self, session_id, **kwargs):
         query = "UPDATE session SET %s WHERE session_id=?" % (', '.join(sets))
         self.cursor.execute(query, list(kwargs.values()) + [session_id])
 
+    def kernel_culled(self, kernel_id):
+        """Checks if the kernel is still considered alive and returns true if its not found. """
+        return kernel_id not in self.kernel_manager
+
+    @gen.coroutine
     def row_to_model(self, row, tolerate_culled=False):
         """Takes sqlite database session row and turns it into a dictionary"""
         kernel_culled = yield maybe_future(self.kernel_culled(row['kernel_id']))
@@ -227,7 +235,7 @@ def row_to_model(self, row, tolerate_culled=False):
                 format(kernel_id=row['kernel_id'],session_id=row['session_id'])
             if tolerate_culled:
                 self.log.warning(msg + "  Continuing...")
-                return None
+                raise gen.Return(None)
             raise KeyError(msg)
 
         kernel_model = yield maybe_future(self.kernel_manager.kernel_model(row['kernel_id']))
@@ -236,13 +244,14 @@ def row_to_model(self, row, tolerate_culled=False):
             'path': row['path'],
             'name': row['name'],
             'type': row['type'],
-            'kernel': self.kernel_manager.kernel_model(row['kernel_id'])
+            'kernel': kernel_model
         }
         if row['type'] == 'notebook':
             # Provide the deprecated API.
             model['notebook'] = {'path': row['path'], 'name': row['name']}
-        return model
+        raise gen.Return(model)
 
+    @gen.coroutine
     def list_sessions(self):
         """Returns a list of dictionaries containing all the information from
         the session database"""
@@ -256,7 +265,7 @@ def list_sessions(self):
                 result.append(model)
             except KeyError:
                 pass
-        return result
+        raise gen.Return(result)
 
     @gen.coroutine
     def delete_session(self, session_id):

jupyter_server/services/sessions/tests/test_sessionmanager.py

@@ -11,25 +11,22 @@
 from jupyter_server.services.contents.manager import ContentsManager
 from jupyter_server._tz import utcnow, isoformat
 
-
 class DummyKernel(object):
     def __init__(self, kernel_name='python'):
         self.kernel_name = kernel_name
 
 dummy_date = utcnow()
 dummy_date_s = isoformat(dummy_date)
 
-
 class DummyMKM(MappingKernelManager):
     """MappingKernelManager interface that doesn't start kernels, for testing"""
-
     def __init__(self, *args, **kwargs):
         super(DummyMKM, self).__init__(*args, **kwargs)
         self.id_letters = iter(u'ABCDEFGHIJK')
 
     def _new_id(self):
         return next(self.id_letters)
-
+    
     def start_kernel(self, kernel_id=None, path=None, kernel_name='python', **kwargs):
         kernel_id = kernel_id or self._new_id()
         k = self._kernels[kernel_id] = DummyKernel(kernel_name=kernel_name)
@@ -43,7 +40,7 @@ def shutdown_kernel(self, kernel_id, now=False):
 
 
 class TestSessionManager(TestCase):
-
+    
     def setUp(self):
         self.sm = SessionManager(
             kernel_manager=DummyMKM(),
@@ -62,14 +59,14 @@ def co_add():
                 sessions.append(session)
             raise gen.Return(sessions)
         return self.loop.run_sync(co_add)
-
+    
     def create_session(self, **kwargs):
         return self.create_sessions(kwargs)[0]
 
     def test_get_session(self):
         sm = self.sm
         session_id = self.create_session(path='/path/to/test.ipynb', kernel_name='bar')['id']
-        model = sm.get_session(session_id=session_id)
+        model = self.loop.run_sync(lambda: sm.get_session(session_id=session_id))
         expected = {'id':session_id,
                     'path': u'/path/to/test.ipynb',
                     'notebook': {'path': u'/path/to/test.ipynb', 'name': None},
@@ -89,17 +86,18 @@ def test_bad_get_session(self):
         sm = self.sm
         session_id = self.create_session(path='/path/to/test.ipynb',
                                        kernel_name='foo')['id']
-        self.assertRaises(TypeError, sm.get_session, bad_id=session_id) # Bad keyword
+        with self.assertRaises(TypeError):
+            self.loop.run_sync(lambda: sm.get_session(bad_id=session_id)) # Bad keyword
 
     def test_get_session_dead_kernel(self):
         sm = self.sm
         session = self.create_session(path='/path/to/1/test1.ipynb', kernel_name='python')
         # kill the kernel
         sm.kernel_manager.shutdown_kernel(session['kernel']['id'])
         with self.assertRaises(KeyError):
-            sm.get_session(session_id=session['id'])
+            self.loop.run_sync(lambda: sm.get_session(session_id=session['id']))
         # no sessions left
-        listed = sm.list_sessions()
+        listed = self.loop.run_sync(lambda: sm.list_sessions())
         self.assertEqual(listed, [])
 
     def test_list_sessions(self):
@@ -109,8 +107,8 @@ def test_list_sessions(self):
             dict(path='/path/to/2/test2.py', type='file', kernel_name='python'),
             dict(path='/path/to/3', name='foo', type='console', kernel_name='python'),
         )
-
-        sessions = sm.list_sessions()
+        
+        sessions = self.loop.run_sync(lambda: sm.list_sessions())
         expected = [
             {
                 'id':sessions[0]['id'],
@@ -161,7 +159,7 @@ def test_list_sessions_dead_kernel(self):
         )
         # kill one of the kernels
         sm.kernel_manager.shutdown_kernel(sessions[0]['kernel']['id'])
-        listed = sm.list_sessions()
+        listed = self.loop.run_sync(lambda: sm.list_sessions())
         expected = [
             {
                 'id': sessions[1]['id'],
@@ -184,8 +182,8 @@ def test_update_session(self):
         sm = self.sm
         session_id = self.create_session(path='/path/to/test.ipynb',
                                        kernel_name='julia')['id']
-        sm.update_session(session_id, path='/path/to/new_name.ipynb')
-        model = sm.get_session(session_id=session_id)
+        self.loop.run_sync(lambda: sm.update_session(session_id, path='/path/to/new_name.ipynb'))
+        model = self.loop.run_sync(lambda: sm.get_session(session_id=session_id))
         expected = {'id':session_id,
                     'path': u'/path/to/new_name.ipynb',
                     'type': 'notebook',
@@ -200,13 +198,14 @@ def test_update_session(self):
                     }
         }
         self.assertEqual(model, expected)
-
+    
     def test_bad_update_session(self):
         # try to update a session with a bad keyword ~ raise error
         sm = self.sm
         session_id = self.create_session(path='/path/to/test.ipynb',
                                        kernel_name='ir')['id']
-        self.assertRaises(TypeError, sm.update_session, session_id=session_id, bad_kw='test.ipynb') # Bad keyword
+        with self.assertRaises(TypeError):
+            self.loop.run_sync(lambda: sm.update_session(session_id=session_id, bad_kw='test.ipynb')) # Bad keyword
 
     def test_delete_session(self):
         sm = self.sm
@@ -215,8 +214,8 @@ def test_delete_session(self):
             dict(path='/path/to/2/test2.ipynb', kernel_name='python'),
             dict(path='/path/to/3', name='foo', type='console', kernel_name='python'),
         )
-        sm.delete_session(sessions[1]['id'])
-        new_sessions = sm.list_sessions()
+        self.loop.run_sync(lambda: sm.delete_session(sessions[1]['id']))
+        new_sessions = self.loop.run_sync(lambda: sm.list_sessions())
         expected = [{
                 'id': sessions[0]['id'],
                 'path': u'/path/to/1/test1.ipynb',

jupyter_server/utils.py

@@ -385,7 +385,6 @@ def _check_pid_posix(pid):
 
 def maybe_future(obj):
     """Like tornado's deprecated gen.maybe_future
-
     but more compatible with asyncio for recent versions
     of tornado
     """

setup.py

@@ -95,7 +95,7 @@
                  'nbval', 'nose-exclude', 'selenium', 'pytest', 'pytest-cov'],
         'test:sys_platform == "win32"': ['nose-exclude'],
     },
-    python_requires='>=3.5',
+    python_requires = '>=3.5',
     entry_points = {
         'console_scripts': [
             'jupyter-server = jupyter_server.serverapp:main',