remove notebook['name'] from sessions

IPython/html/services/sessions/handlers.py

@@ -36,10 +36,6 b' class SessionRootHandler(IPythonHandler):'
         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: notebook.name")
-        try:
             path = model['notebook']['path']
         except KeyError:
             raise web.HTTPError(400, "Missing field in JSON data: notebook.path")
@@ -50,11 +46,11 b' class SessionRootHandler(IPythonHandler):'
             kernel_name = None
 
         # Check to see if session exists
-        if sm.session_exists(name=name, path=path):
-            model = sm.get_session(name=name, path=path)
+        if sm.session_exists(path=path):
+            model = sm.get_session(path=path)
         else:
             try:
-                model = sm.create_session(name=name, path=path, kernel_name=kernel_name)
+                model = sm.create_session(path=path, kernel_name=kernel_name)
             except NoSuchKernel:
                 msg = ("The '%s' kernel is not available. Please pick another "
                        "suitable kernel instead, or install that kernel." % kernel_name)
@@ -92,8 +88,6 b' class SessionHandler(IPythonHandler):'
         changes = {}
         if 'notebook' in model:
             notebook = model['notebook']
-            if 'name' in notebook:
-                changes['name'] = notebook['name']
             if 'path' in notebook:
                 changes['path'] = notebook['path']
 

IPython/html/services/sessions/sessionmanager.py

@@ -21,7 +21,7 b' class SessionManager(LoggingConfigurable):'
     # Session database initialized below
     _cursor = None
     _connection = None
-    _columns = {'session_id', 'name', 'path', 'kernel_id'}
+    _columns = {'session_id', 'path', 'kernel_id'}
     
     @property
     def cursor(self):
@@ -29,7 +29,7 b' class SessionManager(LoggingConfigurable):'
         if self._cursor is None:
             self._cursor = self.connection.cursor()
             self._cursor.execute("""CREATE TABLE session 
-                (session_id, name, path, kernel_id)""")
+                (session_id, path, kernel_id)""")
         return self._cursor
 
     @property
@@ -44,9 +44,9 b' class SessionManager(LoggingConfigurable):'
         """Close connection once SessionManager closes"""
         self.cursor.close()
 
-    def session_exists(self, name, path):
+    def session_exists(self, path):
         """Check to see if the session for a given notebook exists"""
-        self.cursor.execute("SELECT * FROM session WHERE name=? AND path=?", (name, path))
+        self.cursor.execute("SELECT * FROM session WHERE path=?", (path,))
         reply = self.cursor.fetchone()
         if reply is None:
             return False
@@ -57,17 +57,17 b' class SessionManager(LoggingConfigurable):'
         "Create a uuid for a new session"
         return unicode_type(uuid.uuid4())
 
-    def create_session(self, name=None, path=None, kernel_name=None):
+    def create_session(self, path=None, kernel_name=None):
         """Creates a session and returns its model"""
         session_id = self.new_session_id()
         # allow nbm to specify kernels cwd
-        kernel_path = self.contents_manager.get_kernel_path(name=name, path=path)
+        kernel_path = self.contents_manager.get_kernel_path(path=path)
         kernel_id = self.kernel_manager.start_kernel(path=kernel_path,
                                                      kernel_name=kernel_name)
-        return self.save_session(session_id, name=name, path=path,
+        return self.save_session(session_id, path=path,
                                  kernel_id=kernel_id)
 
-    def save_session(self, session_id, name=None, path=None, kernel_id=None):
+    def save_session(self, session_id, path=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
@@ -78,10 +78,8 b' class SessionManager(LoggingConfigurable):'
         ----------
         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
+            the path for the given notebook
         kernel_id : str
             a uuid for the kernel associated with this session
         
@@ -90,8 +88,8 b' class SessionManager(LoggingConfigurable):'
         model : dict
             a dictionary of the session model
         """
-        self.cursor.execute("INSERT INTO session VALUES (?,?,?,?)",
-            (session_id, name, path, kernel_id)
+        self.cursor.execute("INSERT INTO session VALUES (?,?,?)",
+            (session_id, path, kernel_id)
         )
         return self.get_session(session_id=session_id)
 
@@ -105,7 +103,7 b' class SessionManager(LoggingConfigurable):'
         ----------
         **kwargs : keyword argument
             must be given one of the keywords and values from the session database
-            (i.e. session_id, name, path, kernel_id)
+            (i.e. session_id, path, kernel_id)
 
         Returns
         -------
@@ -182,7 +180,6 b' class SessionManager(LoggingConfigurable):'
         model = {
             'id': row['session_id'],
             'notebook': {
-                'name': row['name'],
                 'path': row['path']
             },
             'kernel': self.kernel_manager.kernel_model(row['kernel_id'])

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

@@ -32,24 +32,24 b' class TestSessionManager(TestCase):'
     
     def test_get_session(self):
         sm = SessionManager(kernel_manager=DummyMKM())
-        session_id = sm.create_session(name='test.ipynb', path='/path/to/',
+        session_id = sm.create_session(path='/path/to/test.ipynb',
                                        kernel_name='bar')['id']
         model = sm.get_session(session_id=session_id)
         expected = {'id':session_id,
-                    'notebook':{'name':u'test.ipynb', 'path': u'/path/to/'},
+                    'notebook':{'path': u'/path/to/test.ipynb'},
                     'kernel': {'id':u'A', 'name': 'bar'}}
         self.assertEqual(model, expected)
 
     def test_bad_get_session(self):
         # Should raise error if a bad key is passed to the database.
         sm = SessionManager(kernel_manager=DummyMKM())
-        session_id = sm.create_session(name='test.ipynb', path='/path/to/',
+        session_id = sm.create_session(path='/path/to/test.ipynb',
                                        kernel_name='foo')['id']
         self.assertRaises(TypeError, sm.get_session, bad_id=session_id) # Bad keyword
 
     def test_get_session_dead_kernel(self):
         sm = SessionManager(kernel_manager=DummyMKM())
-        session = sm.create_session(name='test1.ipynb', path='/path/to/1/', kernel_name='python')
+        session = sm.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):
@@ -61,24 +61,33 b' class TestSessionManager(TestCase):'
     def test_list_sessions(self):
         sm = SessionManager(kernel_manager=DummyMKM())
         sessions = [
-            sm.create_session(name='test1.ipynb', path='/path/to/1/', kernel_name='python'),
-            sm.create_session(name='test2.ipynb', path='/path/to/2/', kernel_name='python'),
-            sm.create_session(name='test3.ipynb', path='/path/to/3/', kernel_name='python'),
+            sm.create_session(path='/path/to/1/test1.ipynb', kernel_name='python'),
+            sm.create_session(path='/path/to/2/test2.ipynb', kernel_name='python'),
+            sm.create_session(path='/path/to/3/test3.ipynb', kernel_name='python'),
         ]
         sessions = sm.list_sessions()
-        expected = [{'id':sessions[0]['id'], 'notebook':{'name':u'test1.ipynb', 
-                    'path': u'/path/to/1/'}, 'kernel':{'id':u'A', 'name':'python'}},
-                    {'id':sessions[1]['id'], 'notebook': {'name':u'test2.ipynb', 
-                    'path': u'/path/to/2/'}, 'kernel':{'id':u'B', 'name':'python'}},
-                    {'id':sessions[2]['id'], 'notebook':{'name':u'test3.ipynb', 
-                    'path': u'/path/to/3/'}, 'kernel':{'id':u'C', 'name':'python'}}]
+        expected = [
+            {
+                'id':sessions[0]['id'],
+                'notebook':{'path': u'/path/to/1/test1.ipynb'},
+                'kernel':{'id':u'A', 'name':'python'}
+            }, {
+                'id':sessions[1]['id'],
+                'notebook': {'path': u'/path/to/2/test2.ipynb'},
+                'kernel':{'id':u'B', 'name':'python'}
+            }, {
+                'id':sessions[2]['id'],
+                'notebook':{'path': u'/path/to/3/test3.ipynb'},
+                'kernel':{'id':u'C', 'name':'python'}
+            }
+        ]
         self.assertEqual(sessions, expected)
 
     def test_list_sessions_dead_kernel(self):
         sm = SessionManager(kernel_manager=DummyMKM())
         sessions = [
-            sm.create_session(name='test1.ipynb', path='/path/to/1/', kernel_name='python'),
-            sm.create_session(name='test2.ipynb', path='/path/to/2/', kernel_name='python'),
+            sm.create_session(path='/path/to/1/test1.ipynb', kernel_name='python'),
+            sm.create_session(path='/path/to/2/test2.ipynb', kernel_name='python'),
         ]
         # kill one of the kernels
         sm.kernel_manager.shutdown_kernel(sessions[0]['kernel']['id'])
@@ -87,8 +96,7 b' class TestSessionManager(TestCase):'
             {
                 'id': sessions[1]['id'],
                 'notebook': {
-                    'name': u'test2.ipynb',
-                    'path': u'/path/to/2/',
+                    'path': u'/path/to/2/test2.ipynb',
                 },
                 'kernel': {
                     'id': u'B',
@@ -100,41 +108,47 b' class TestSessionManager(TestCase):'
 
     def test_update_session(self):
         sm = SessionManager(kernel_manager=DummyMKM())
-        session_id = sm.create_session(name='test.ipynb', path='/path/to/',
+        session_id = sm.create_session(path='/path/to/test.ipynb',
                                        kernel_name='julia')['id']
-        sm.update_session(session_id, name='new_name.ipynb')
+        sm.update_session(session_id, path='/path/to/new_name.ipynb')
         model = sm.get_session(session_id=session_id)
         expected = {'id':session_id,
-                    'notebook':{'name':u'new_name.ipynb', 'path': u'/path/to/'},
+                    'notebook':{'path': u'/path/to/new_name.ipynb'},
                     'kernel':{'id':u'A', 'name':'julia'}}
         self.assertEqual(model, expected)
     
     def test_bad_update_session(self):
         # try to update a session with a bad keyword ~ raise error
         sm = SessionManager(kernel_manager=DummyMKM())
-        session_id = sm.create_session(name='test.ipynb', path='/path/to/',
+        session_id = sm.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
 
     def test_delete_session(self):
         sm = SessionManager(kernel_manager=DummyMKM())
         sessions = [
-            sm.create_session(name='test1.ipynb', path='/path/to/1/', kernel_name='python'),
-            sm.create_session(name='test2.ipynb', path='/path/to/2/', kernel_name='python'),
-            sm.create_session(name='test3.ipynb', path='/path/to/3/', kernel_name='python'),
+            sm.create_session(path='/path/to/1/test1.ipynb', kernel_name='python'),
+            sm.create_session(path='/path/to/2/test2.ipynb', kernel_name='python'),
+            sm.create_session(path='/path/to/3/test3.ipynb', kernel_name='python'),
         ]
         sm.delete_session(sessions[1]['id'])
         new_sessions = sm.list_sessions()
-        expected = [{'id':sessions[0]['id'], 'notebook':{'name':u'test1.ipynb', 
-                    'path': u'/path/to/1/'}, 'kernel':{'id':u'A', 'name':'python'}},
-                    {'id':sessions[2]['id'], 'notebook':{'name':u'test3.ipynb', 
-                    'path': u'/path/to/3/'}, 'kernel':{'id':u'C', 'name':'python'}}]
+        expected = [{
+                'id': sessions[0]['id'],
+                'notebook': {'path': u'/path/to/1/test1.ipynb'},
+                'kernel': {'id':u'A', 'name':'python'}
+            }, {
+                'id': sessions[2]['id'],
+                'notebook': {'path': u'/path/to/3/test3.ipynb'},
+                'kernel': {'id':u'C', 'name':'python'}
+            }
+        ]
         self.assertEqual(new_sessions, expected)
 
     def test_bad_delete_session(self):
         # try to delete a session that doesn't exist ~ raise error
         sm = SessionManager(kernel_manager=DummyMKM())
-        sm.create_session(name='test.ipynb', path='/path/to/', kernel_name='python')
+        sm.create_session(path='/path/to/test.ipynb', kernel_name='python')
         self.assertRaises(TypeError, sm.delete_session, bad_kwarg='23424') # Bad keyword
         self.assertRaises(web.HTTPError, sm.delete_session, session_id='23424') # nonexistant
 

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

@@ -38,13 +38,13 b' class SessionAPI(object):'
     def get(self, id):
         return self._req('GET', id)
 
-    def create(self, name, path, kernel_name='python'):
-        body = json.dumps({'notebook': {'name':name, 'path':path},
+    def create(self, path, kernel_name='python'):
+        body = json.dumps({'notebook': {'path':path},
                            'kernel': {'name': kernel_name}})
         return self._req('POST', '', body)
 
-    def modify(self, id, name, path):
-        body = json.dumps({'notebook': {'name':name, 'path':path}})
+    def modify(self, id, path):
+        body = json.dumps({'notebook': {'path':path}})
         return self._req('PATCH', id, body)
 
     def delete(self, id):
@@ -78,12 +78,11 b' class SessionAPITest(NotebookTestBase):'
         sessions = self.sess_api.list().json()
         self.assertEqual(len(sessions), 0)
 
-        resp = self.sess_api.create('nb1.ipynb', 'foo')
+        resp = self.sess_api.create('foo/nb1.ipynb')
         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')
+        self.assertEqual(newsession['notebook']['path'], 'foo/nb1.ipynb')
         self.assertEqual(resp.headers['Location'], '/api/sessions/{0}'.format(newsession['id']))
 
         sessions = self.sess_api.list().json()
@@ -95,7 +94,7 b' class SessionAPITest(NotebookTestBase):'
         self.assertEqual(got, newsession)
 
     def test_delete(self):
-        newsession = self.sess_api.create('nb1.ipynb', 'foo').json()
+        newsession = self.sess_api.create('foo/nb1.ipynb').json()
         sid = newsession['id']
 
         resp = self.sess_api.delete(sid)
@@ -108,10 +107,9 b' class SessionAPITest(NotebookTestBase):'
             self.sess_api.get(sid)
 
     def test_modify(self):
-        newsession = self.sess_api.create('nb1.ipynb', 'foo').json()
+        newsession = self.sess_api.create('foo/nb1.ipynb').json()
         sid = newsession['id']
 
-        changed = self.sess_api.modify(sid, 'nb2.ipynb', '').json()
+        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'], '')
+        self.assertEqual(changed['notebook']['path'], 'nb2.ipynb')