restore ability to sign v3 notebooks

IPython/html/services/contents/manager.py

@@ -309,15 +309,12 b' class ContentsManager(LoggingConfigurable):'
         Parameters
         ----------
         nb : dict
-            The notebook object (in current nbformat)
+            The notebook dict
         name : string
             The filename of the notebook (for logging)
         path : string
             The notebook's directory (for logging)
         """
-        # can't sign old notebooks
-        if nb['nbformat'] != 4:
-            return
         if self.notary.check_cells(nb):
             self.notary.sign(nb)
         else:

IPython/nbformat/sign.py

@@ -46,6 +46,20 b' def yield_everything(obj):'
     else:
         yield unicode_type(obj).encode('utf8')
 
+def yield_code_cells(nb):
+    """Iterator that yields all cells in a notebook
+    
+    nbformat version independent
+    """
+    if nb.nbformat >= 4:
+        for cell in nb['cells']:
+            if cell['cell_type'] == 'code':
+                yield cell
+    elif nb.nbformat == 3:
+        for ws in nb['worksheets']:
+            for cell in ws['cells']:
+                if cell['cell_type'] == 'code':
+                    yield cell
 
 @contextmanager
 def signature_removed(nb):
@@ -152,6 +166,8 b' class NotebookNotary(LoggingConfigurable):'
         - the requested scheme is available from hashlib
         - the computed hash from notebook_signature matches the stored hash
         """
+        if nb.nbformat < 3:
+            return False
         stored_signature = nb['metadata'].get('signature', None)
         if not stored_signature \
             or not isinstance(stored_signature, string_types) \
@@ -170,6 +186,8 b' class NotebookNotary(LoggingConfigurable):'
         
         e.g. 'sha256:deadbeef123...'
         """
+        if nb.nbformat < 3:
+            return
         signature = self.compute_signature(nb)
         nb['metadata']['signature'] = "%s:%s" % (self.algorithm, signature)
     
@@ -181,11 +199,13 b' class NotebookNotary(LoggingConfigurable):'
         
         This function is the inverse of check_cells
         """
-        for cell in nb['cells']:
-            if cell['cell_type'] == 'code':
-                cell['metadata']['trusted'] = trusted
+        if nb.nbformat < 3:
+            return
+        
+        for cell in yield_code_cells(nb):
+            cell['metadata']['trusted'] = trusted
     
-    def _check_cell(self, cell):
+    def _check_cell(self, cell, nbformat_version):
         """Do we trust an individual cell?
         
         Return True if:
@@ -201,16 +221,21 b' class NotebookNotary(LoggingConfigurable):'
             return True
         
         # explicitly safe output
-        safe = {
-            'text/plain', 'image/png', 'image/jpeg',
-        }
+        if nbformat_version >= 4:
+            safe = {'text/plain', 'image/png', 'image/jpeg'}
+            unsafe_output_types = ['execute_result', 'display_data']
+            safe_keys = {"output_type", "execution_count", "metadata"}
+        else: # v3
+            safe = {'text', 'png', 'jpeg'}
+            unsafe_output_types = ['pyout', 'display_data']
+            safe_keys = {"output_type", "prompt_number", "metadata"}
         
         for output in cell['outputs']:
             output_type = output['output_type']
-            if output_type in {'execute_result', 'display_data'}:
+            if output_type in unsafe_output_types:
                 # if there are any data keys not in the safe whitelist
-                output_keys = set(output).difference({"output_type", "execution_count", "metadata"})
-                if output_keys.difference(safe):
+                output_keys = set(output)
+                if output_keys.difference(safe_keys):
                     return False
         
         return True
@@ -222,12 +247,12 b' class NotebookNotary(LoggingConfigurable):'
         
         This function is the inverse of mark_cells.
         """
+        if nb.nbformat < 3:
+            return False
         trusted = True
-        for cell in nb['cells']:
-            if cell['cell_type'] != 'code':
-                continue
+        for cell in yield_code_cells(nb):
             # only distrust a cell if it actually has some output to distrust
-            if not self._check_cell(cell):
+            if not self._check_cell(cell, nb.nbformat):
                 trusted = False
 
         return trusted

IPython/nbformat/tests/test_sign.py

@@ -18,6 +18,8 b' class TestNotary(TestsBase):'
         )
         with self.fopen(u'test3.ipynb', u'r') as f:
             self.nb = read(f, as_version=4)
+        with self.fopen(u'test3.ipynb', u'r') as f:
+            self.nb3 = read(f, as_version=3)
     
     def test_algorithms(self):
         last_sig = ''
@@ -108,4 +110,41 b' class TestNotary(TestsBase):'
             if cell.cell_type == 'code':
                 cell.outputs = []
         self.assertTrue(self.notary.check_cells(nb))
+    
+    def test_mark_cells_untrusted_v3(self):
+        nb = self.nb3
+        cells = nb.worksheets[0].cells
+        self.notary.mark_cells(nb, False)
+        for cell in cells:
+            self.assertNotIn('trusted', cell)
+            if cell.cell_type == 'code':
+                self.assertIn('trusted', cell.metadata)
+                self.assertFalse(cell.metadata.trusted)
+            else:
+                self.assertNotIn('trusted', cell.metadata)
+    
+    def test_mark_cells_trusted_v3(self):
+        nb = self.nb3
+        cells = nb.worksheets[0].cells
+        self.notary.mark_cells(nb, True)
+        for cell in cells:
+            self.assertNotIn('trusted', cell)
+            if cell.cell_type == 'code':
+                self.assertIn('trusted', cell.metadata)
+                self.assertTrue(cell.metadata.trusted)
+            else:
+                self.assertNotIn('trusted', cell.metadata)
+    
+    def test_check_cells_v3(self):
+        nb = self.nb3
+        cells = nb.worksheets[0].cells
+        self.notary.mark_cells(nb, True)
+        self.assertTrue(self.notary.check_cells(nb))
+        for cell in cells:
+            self.assertNotIn('trusted', cell)
+        self.notary.mark_cells(nb, False)
+        self.assertFalse(self.notary.check_cells(nb))
+        for cell in cells:
+            self.assertNotIn('trusted', cell)
+