Clean up sessions code from static analysis

IPython/html/services/sessions/handlers.py

@@ -1,126 +1,123 b''
 """Tornado handlers for the sessions web service.
 
 Authors:
 
 * Zach Sailer
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import json
 
 from tornado import web
 from IPython.utils.jsonutil import date_default
 from ...base.handlers import IPythonHandler, json_errors
 
 #-----------------------------------------------------------------------------
 # Session web service handlers
 #-----------------------------------------------------------------------------
 
 
 class SessionRootHandler(IPythonHandler):
 
     @web.authenticated
     @json_errors
     def get(self):
         # Return a list of running sessions
         sm = self.session_manager
         sessions = sm.list_sessions()
         self.finish(json.dumps(sessions, default=date_default))
 
     @web.authenticated
     @json_errors
     def post(self):
         # Creates a new session 
         #(unless a session already exists for the named nb)
         sm = self.session_manager
         nbm = self.notebook_manager
         km = self.kernel_manager
         model = self.get_json_body()
         if model is None:
             raise web.HTTPError(400, "No JSON data provided")
         try:
             name = model['notebook']['name']
         except KeyError:
             raise web.HTTPError(400, "Missing field in JSON data: name")
         try:
             path = model['notebook']['path']
         except KeyError:
             raise web.HTTPError(400, "Missing field in JSON data: path")
         # Check to see if session exists
         if sm.session_exists(name=name, path=path):
             model = sm.get_session(name=name, path=path)
         else:
             kernel_id = km.start_kernel(cwd=nbm.notebook_dir)
             model = sm.create_session(name=name, path=path, kernel_id=kernel_id, ws_url=self.ws_url)
         self.set_header('Location', '{0}/api/sessions/{1}'.format(self.base_project_url, model['id']))
         self.set_status(201)
         self.finish(json.dumps(model, default=date_default))
 
 class SessionHandler(IPythonHandler):
 
     SUPPORTED_METHODS = ('GET', 'PATCH', 'DELETE')
 
     @web.authenticated
     @json_errors
     def get(self, session_id):
         # Returns the JSON model for a single session
         sm = self.session_manager
         model = sm.get_session(id=session_id)
         self.finish(json.dumps(model, default=date_default))
 
     @web.authenticated
     @json_errors
     def patch(self, session_id):
         # Currently, this handler is strictly for renaming notebooks
         sm = self.session_manager
-        nbm = self.notebook_manager
-        km = self.kernel_manager
         model = self.get_json_body()
         if model is None:
-            raise HTTPError(400, "No JSON data provided")
+            raise web.HTTPError(400, "No JSON data provided")
         changes = {}
         if 'notebook' in model:
             notebook = model['notebook']
             if 'name' in notebook:
                 changes['name'] = notebook['name']
             if 'path' in notebook:
                 changes['path'] = notebook['path']
         sm.update_session(session_id, **changes)
         model = sm.get_session(id=session_id)
         self.finish(json.dumps(model, default=date_default))
 
     @web.authenticated
     @json_errors
     def delete(self, session_id):
         # Deletes the session with given session_id
         sm = self.session_manager
-        nbm = self.notebook_manager
         km = self.kernel_manager
         session = sm.get_session(id=session_id)
         sm.delete_session(session_id)        
         km.shutdown_kernel(session['kernel']['id'])
         self.set_status(204)
         self.finish()
 
 
 #-----------------------------------------------------------------------------
 # URL to handler mappings
 #-----------------------------------------------------------------------------
 
 _session_id_regex = r"(?P<session_id>\w+-\w+-\w+-\w+-\w+)"
 
 default_handlers = [
     (r"/api/sessions/%s" % _session_id_regex, SessionHandler),
     (r"/api/sessions",  SessionRootHandler)
 ]
 

IPython/html/services/sessions/sessionmanager.py

@@ -1,187 +1,185 b''
 """A base class session manager.
 
 Authors:
 
 * Zach Sailer
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
-import os
 import uuid
 import sqlite3
 
 from tornado import web
 
 from IPython.config.configurable import LoggingConfigurable
-from IPython.nbformat import current
-from IPython.utils.traitlets import List, Dict, Unicode, TraitError
+from IPython.utils.traitlets import TraitError
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class SessionManager(LoggingConfigurable):
     
     # Session database initialized below
     _cursor = None
     _connection = None
     
     @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 
                 (id, name, path, kernel_id, ws_url)""")
         return self._cursor
 
     @property
     def connection(self):
         """Start a database connection"""
         if self._connection is None:
             self._connection = sqlite3.connect(':memory:')
             self._connection.row_factory = sqlite3.Row
         return self._connection
         
     def __del__(self):
         """Close connection once SessionManager closes"""
         self.cursor.close()
 
     def session_exists(self, name, path):
         """Check to see if the session for the given notebook exists"""
         self.cursor.execute("SELECT * FROM session WHERE name=? AND path=?", (name,path))
         reply = self.cursor.fetchone()
         if reply is None:
             return False
         else:
             return True
 
     def get_session_id(self):
         "Create a uuid for a new session"
         return unicode(uuid.uuid4())
 
     def create_session(self, name=None, path=None, kernel_id=None, ws_url=None):
         """Creates a session and returns its model"""
         session_id = self.get_session_id()
         return self.save_session(session_id, name=name, path=path, kernel_id=kernel_id, ws_url=ws_url)
 
     def save_session(self, session_id, name=None, path=None, kernel_id=None, ws_url=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
             uuid for the session; this method must be given a session_id
         name : str
             the .ipynb notebook name that started the session
         path : str
             the path to the named notebook
         kernel_id : str
             a uuid for the kernel associated with this session
         ws_url : str
             the websocket url
             
         Returns
         -------
         model : dict
             a dictionary of the session model
         """
         self.cursor.execute("""INSERT INTO session VALUES 
             (?,?,?,?,?)""", (session_id, name, path, kernel_id, ws_url))
         self.connection.commit()
         return self.get_session(id=session_id)
 
     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.
 
         Parameters
         ----------
         **kwargs : keyword argument
             must be given one of the keywords and values from the session database
             (i.e. session_id, name, path, kernel_id, ws_url)
 
         Returns
         -------
         model : dict
             returns a dictionary that includes all the information from the 
             session described by the kwarg.
         """
         column = kwargs.keys()[0] # uses only the first kwarg that is entered
         value = kwargs.values()[0]
         try:
             self.cursor.execute("SELECT * FROM session WHERE %s=?" %column, (value,))
         except sqlite3.OperationalError:
             raise TraitError("The session database has no column: %s" %column)
         reply = self.cursor.fetchone()
         if reply is not None:
             model = self.reply_to_dictionary_model(reply)
         else:
             raise web.HTTPError(404, u'Session not found: %s=%r' % (column, value))
         return model
 
     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. 
         
         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 
             with session_id.
         """
         for kwarg in kwargs:
             try:
                 self.cursor.execute("UPDATE session SET %s=? WHERE id=?" %kwarg, (kwargs[kwarg], session_id))
                 self.connection.commit()
             except sqlite3.OperationalError:
                 raise TraitError("No session exists with ID: %s" %session_id)
 
     def reply_to_dictionary_model(self, reply):
         """Takes sqlite database session row and turns it into a dictionary"""
         model = {'id': reply['id'],
                  'notebook': {'name': reply['name'], 'path': reply['path']},
                  'kernel': {'id': reply['kernel_id'], 'ws_url': reply['ws_url']}}
         return model
         
     def list_sessions(self):
         """Returns a list of dictionaries containing all the information from
         the session database"""
         session_list=[]
         self.cursor.execute("SELECT * FROM session")
         sessions = self.cursor.fetchall()
         for session in sessions:
             model = self.reply_to_dictionary_model(session)
             session_list.append(model)
         return session_list
 
     def delete_session(self, session_id):
         """Deletes the row in the session database with given session_id"""
         # Check that session exists before deleting
         model = self.get_session(id=session_id)
         if model is None:
             raise TraitError("The session does not exist: %s" %session_id)
         else: 
             self.cursor.execute("DELETE FROM session WHERE id=?", (session_id,))
             self.connection.commit()
  No newline at end of file

IPython/html/services/sessions/tests/test_sessions_api.py

@@ -1,114 +1,113 b''
 """Test the sessions web service API."""
 
 import io
 import os
 import json
 import requests
 import shutil
 
 pjoin = os.path.join
 
-from IPython.utils.jsonutil import date_default
 from IPython.html.utils import url_path_join
 from IPython.html.tests.launchnotebook import NotebookTestBase
 from IPython.nbformat.current import new_notebook, write
 
 class SessionAPI(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, 'api/sessions', path), data=body)
 
         if 400 <= response.status_code < 600:
             try:
                 response.reason = response.json()['message']
             except:
                 pass
         response.raise_for_status()
 
         return response
 
     def list(self):
         return self._req('GET', '')
 
     def get(self, id):
         return self._req('GET', id)
 
     def create(self, name, path):
         body = json.dumps({'notebook': {'name':name, 'path':path}})
         return self._req('POST', '', body)
 
     def modify(self, id, name, path):
         body = json.dumps({'notebook': {'name':name, 'path':path}})
         return self._req('PATCH', id, body)
 
     def delete(self, id):
         return self._req('DELETE', id)
 
 class SessionAPITest(NotebookTestBase):
     """Test the sessions web service API"""
     def setUp(self):
         nbdir = self.notebook_dir.name
         os.mkdir(pjoin(nbdir, 'foo'))
 
         with io.open(pjoin(nbdir, 'foo', 'nb1.ipynb'), 'w') as f:
             nb = new_notebook(name='nb1')
             write(nb, f, format='ipynb')
 
         self.sess_api = SessionAPI(self.base_url())
 
     def tearDown(self):
         for session in self.sess_api.list().json():
             self.sess_api.delete(session['id'])
         shutil.rmtree(pjoin(self.notebook_dir.name, 'foo'))
 
     def assert_404(self, id):
         try:
             self.sess_api.get(id)
         except requests.HTTPError as e:
             self.assertEqual(e.response.status_code, 404)
         else:
             assert False, "Getting nonexistent session didn't give HTTP error"
 
     def test_create(self):
         sessions = self.sess_api.list().json()
         self.assertEqual(len(sessions), 0)
 
         resp = self.sess_api.create('nb1.ipynb', 'foo')
         self.assertEqual(resp.status_code, 201)
         newsession = resp.json()
         self.assertIn('id', newsession)
         self.assertEqual(newsession['notebook']['name'], 'nb1.ipynb')
         self.assertEqual(newsession['notebook']['path'], 'foo')
 
         sessions = self.sess_api.list().json()
         self.assertEqual(sessions, [newsession])
 
         # Retrieve it
         sid = newsession['id']
         got = self.sess_api.get(sid).json()
         self.assertEqual(got, newsession)
 
     def test_delete(self):
         newsession = self.sess_api.create('nb1.ipynb', 'foo').json()
         sid = newsession['id']
 
         resp = self.sess_api.delete(sid)
         self.assertEqual(resp.status_code, 204)
 
         sessions = self.sess_api.list().json()
         self.assertEqual(sessions, [])
 
         self.assert_404(sid)
 
     def test_modify(self):
         newsession = self.sess_api.create('nb1.ipynb', 'foo').json()
         sid = newsession['id']
 
         changed = self.sess_api.modify(sid, 'nb2.ipynb', '').json()
         self.assertEqual(changed['id'], sid)
         self.assertEqual(changed['notebook']['name'], 'nb2.ipynb')
         self.assertEqual(changed['notebook']['path'], '')