Add preprocessor to execute notebooks

IPython/nbconvert/preprocessors/execute.py

@@ -0,0 +1,109 b''
+"""Module containing a preprocessor that removes the outputs from code cells"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+import os
+import sys
+
+from Queue import Empty
+from IPython.kernel import KernelManager
+from IPython.nbformat.current import reads, NotebookNode, writes
+
+from .base import Preprocessor
+
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+class ExecutePreprocessor(Preprocessor):
+    """
+    Executes all the cells in a notebook
+    """
+    def __init__(self, *args, **kwargs):
+        """
+        Start an kernel to run the Python code
+        """
+        super(ExecutePreprocessor, self).__init__(*args, **kwargs)
+        self.km = KernelManager()
+        # run %pylab inline, because some notebooks assume this
+        # even though they shouldn't
+        self.km.start_kernel(extra_arguments=['--pylab=inline'], stderr=open(os.devnull, 'w'))
+        self.kc = self.km.client()
+        self.kc.start_channels()
+        self.iopub = self.kc.iopub_channel
+        self.shell = self.kc.shell_channel
+        
+        self.shell.execute("pass")
+        self.shell.get_msg()
+                    
+    def preprocess_cell(self, cell, resources, cell_index):
+        """
+        Apply a transformation on each code cell. See base.py for details.
+        """
+        if cell.cell_type != 'code':
+            return cell, resources
+        try:
+            outputs = self.run_cell(self.shell, self.iopub, cell)
+        except Exception as e:
+            print >> sys.stderr, "failed to run cell:", repr(e)
+            print >> sys.stderr, cell.input
+            sys.exit(1)
+        cell.outputs = outputs
+        return cell, resources
+
+    @staticmethod
+    def run_cell(shell, iopub, cell):
+        # print cell.input
+        shell.execute(cell.input)
+        # wait for finish, maximum 20s
+        shell.get_msg(timeout=20)
+        outs = []
+        
+        while True:
+            try:
+                msg = iopub.get_msg(timeout=0.2)
+            except Empty:
+                break
+            msg_type = msg['msg_type']
+            if msg_type in ('status', 'pyin'):
+                continue
+            elif msg_type == 'clear_output':
+                outs = []
+                continue
+            
+            content = msg['content']
+            # print msg_type, content
+            out = NotebookNode(output_type=msg_type)
+            
+            if msg_type == 'stream':
+                out.stream = content['name']
+                out.text = content['data']
+            elif msg_type in ('display_data', 'pyout'):
+                out['metadata'] = content['metadata']
+                for mime, data in content['data'].iteritems():
+                    attr = mime.split('/')[-1].lower()
+                    # this gets most right, but fix svg+html, plain
+                    attr = attr.replace('+xml', '').replace('plain', 'text')
+                    setattr(out, attr, data)
+                if msg_type == 'pyout':
+                    out.prompt_number = content['execution_count']
+            elif msg_type == 'pyerr':
+                out.ename = content['ename']
+                out.evalue = content['evalue']
+                out.traceback = content['traceback']
+            else:
+                print >> sys.stderr, "unhandled iopub msg:", msg_type
+            
+            outs.append(out)
+        return outs
+        
+
+    def __del__(self):
+        self.kc.stop_channels()
+        self.km.shutdown_kernel()
+        del self.km

IPython/nbconvert/preprocessors/tests/test_execute.py

@@ -0,0 +1,45 b''
+"""
+Module with tests for the clearoutput preprocessor.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+import copy
+
+from IPython.nbformat import current as nbformat
+
+from .base import PreprocessorTestsBase
+from ..execute import ExecutePreprocessor
+
+
+#-----------------------------------------------------------------------------
+# Class
+#-----------------------------------------------------------------------------
+
+class TestExecute(PreprocessorTestsBase):
+    """Contains test functions for execute.py"""
+
+
+    def build_preprocessor(self):
+        """Make an instance of a preprocessor"""
+        preprocessor = ExecutePreprocessor()
+        preprocessor.enabled = True
+        return preprocessor
+
+    def test_constructor(self):
+        """Can a ExecutePreprocessor be constructed?"""
+        self.build_preprocessor()
+
+    def test_correct_output(self):
+        """Test that ExecutePreprocessor evaluates a cell to the right thing"""
+        nb = self.build_notebook()
+        res = self.build_resources()
+        nb.worksheets[0].cells[0].input = "print 'hi!'"
+        preprocessor = self.build_preprocessor()
+        nb, res = preprocessor(nb, res)
+        expected_outputs = [{'output_type': 'stream', 'stream': 'stdout', 'text': 'hi!\n'}] 
+        assert nb.worksheets[0].cells[0].outputs == expected_outputs

IPython/nbconvert/exporters/exporter.py

@@ -1,276 +1,277 b''
 """This module defines a base Exporter class. For Jinja template-based export,
 see templateexporter.py.
 """
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from __future__ import print_function, absolute_import
 
 # Stdlib imports
 import io
 import os
 import copy
 import collections
 import datetime
 
 
 # IPython imports
 from IPython.config.configurable import LoggingConfigurable
 from IPython.config import Config
 from IPython.nbformat import current as nbformat
 from IPython.utils.traitlets import MetaHasTraits, Unicode, List
 from IPython.utils.importstring import import_item
 from IPython.utils import text, py3compat
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class ResourcesDict(collections.defaultdict):
     def __missing__(self, key):
         return ''
 
 
 class Exporter(LoggingConfigurable):
     """
     Class containing methods that sequentially run a list of preprocessors on a 
     NotebookNode object and then return the modified NotebookNode object and 
     accompanying resources dict.
     """
 
     file_extension = Unicode(
         'txt', config=True,
         help="Extension of the file that should be written to disk"
         )
 
     # MIME type of the result file, for HTTP response headers.
     # This is *not* a traitlet, because we want to be able to access it from
     # the class, not just on instances.
     output_mimetype = ''
 
     #Configurability, allows the user to easily add filters and preprocessors.
     preprocessors = List(config=True,
         help="""List of preprocessors, by name or namespace, to enable.""")
 
     _preprocessors = List()
 
     default_preprocessors = List(['IPython.nbconvert.preprocessors.coalesce_streams',
                                   'IPython.nbconvert.preprocessors.SVG2PDFPreprocessor',
                                   'IPython.nbconvert.preprocessors.ExtractOutputPreprocessor',
                                   'IPython.nbconvert.preprocessors.CSSHTMLHeaderPreprocessor',
                                   'IPython.nbconvert.preprocessors.RevealHelpPreprocessor',
                                   'IPython.nbconvert.preprocessors.LatexPreprocessor',
                                   'IPython.nbconvert.preprocessors.ClearOutputPreprocessor',
+                                  'IPython.nbconvert.preprocessors.ExecutePreprocessor',
                                   'IPython.nbconvert.preprocessors.HighlightMagicsPreprocessor'],
         config=True,
         help="""List of preprocessors available by default, by name, namespace, 
         instance, or type.""")
 
 
     def __init__(self, config=None, **kw):
         """
         Public constructor
 
         Parameters
         ----------
         config : config
             User configuration instance.
         """
         with_default_config = self.default_config
         if config:
             with_default_config.merge(config)
         
         super(Exporter, self).__init__(config=with_default_config, **kw)
 
         self._init_preprocessors()
 
 
     @property
     def default_config(self):
         return Config()
 
     @nbformat.docstring_nbformat_mod
     def from_notebook_node(self, nb, resources=None, **kw):
         """
         Convert a notebook from a notebook node instance.
 
         Parameters
         ----------
         nb : :class:`~{nbformat_mod}.nbbase.NotebookNode`
           Notebook node
         resources : dict
           Additional resources that can be accessed read/write by
           preprocessors and filters.
         **kw
           Ignored (?)
         """
         nb_copy = copy.deepcopy(nb)
         resources = self._init_resources(resources)
         
         if 'language' in nb['metadata']:
             resources['language'] = nb['metadata']['language'].lower()
 
         # Preprocess
         nb_copy, resources = self._preprocess(nb_copy, resources)
 
         return nb_copy, resources
 
 
     def from_filename(self, filename, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
 
         Parameters
         ----------
         filename : str
             Full filename of the notebook file to open and convert.
         """
 
         # Pull the metadata from the filesystem.
         if resources is None:
             resources = ResourcesDict()
         if not 'metadata' in resources or resources['metadata'] == '':
             resources['metadata'] = ResourcesDict()
         basename = os.path.basename(filename)
         notebook_name = basename[:basename.rfind('.')]
         resources['metadata']['name'] = notebook_name
 
         modified_date = datetime.datetime.fromtimestamp(os.path.getmtime(filename))
         resources['metadata']['modified_date'] = modified_date.strftime(text.date_format)
 
         with io.open(filename, encoding='utf-8') as f:
             return self.from_notebook_node(nbformat.read(f, 'json'), resources=resources, **kw)
 
 
     def from_file(self, file_stream, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
 
         Parameters
         ----------
         file_stream : file-like object
             Notebook file-like object to convert.
         """
         return self.from_notebook_node(nbformat.read(file_stream, 'json'), resources=resources, **kw)
 
 
     def register_preprocessor(self, preprocessor, enabled=False):
         """
         Register a preprocessor.
         Preprocessors are classes that act upon the notebook before it is
         passed into the Jinja templating engine.  preprocessors are also
         capable of passing additional information to the Jinja
         templating engine.
 
         Parameters
         ----------
         preprocessor : preprocessor
         """
         if preprocessor is None:
             raise TypeError('preprocessor')
         isclass = isinstance(preprocessor, type)
         constructed = not isclass
 
         # Handle preprocessor's registration based on it's type
         if constructed and isinstance(preprocessor, py3compat.string_types):
             # Preprocessor is a string, import the namespace and recursively call
             # this register_preprocessor method
             preprocessor_cls = import_item(preprocessor)
             return self.register_preprocessor(preprocessor_cls, enabled)
 
         if constructed and hasattr(preprocessor, '__call__'):
             # Preprocessor is a function, no need to construct it.
             # Register and return the preprocessor.
             if enabled:
                 preprocessor.enabled = True
             self._preprocessors.append(preprocessor)
             return preprocessor
 
         elif isclass and isinstance(preprocessor, MetaHasTraits):
             # Preprocessor is configurable.  Make sure to pass in new default for 
             # the enabled flag if one was specified.
             self.register_preprocessor(preprocessor(parent=self), enabled)
 
         elif isclass:
             # Preprocessor is not configurable, construct it
             self.register_preprocessor(preprocessor(), enabled)
 
         else:
             # Preprocessor is an instance of something without a __call__ 
             # attribute.  
             raise TypeError('preprocessor')
 
 
     def _init_preprocessors(self):
         """
         Register all of the preprocessors needed for this exporter, disabled
         unless specified explicitly.
         """
         self._preprocessors = []
 
         # Load default preprocessors (not necessarly enabled by default).
         for preprocessor in self.default_preprocessors:
             self.register_preprocessor(preprocessor)
 
         # Load user-specified preprocessors.  Enable by default.
         for preprocessor in self.preprocessors:
             self.register_preprocessor(preprocessor, enabled=True)
 
 
     def _init_resources(self, resources):
 
         #Make sure the resources dict is of ResourcesDict type.
         if resources is None:
             resources = ResourcesDict()
         if not isinstance(resources, ResourcesDict):
             new_resources = ResourcesDict()
             new_resources.update(resources)
             resources = new_resources
 
         #Make sure the metadata extension exists in resources
         if 'metadata' in resources:
             if not isinstance(resources['metadata'], ResourcesDict):
                 resources['metadata'] = ResourcesDict(resources['metadata'])
         else:
             resources['metadata'] = ResourcesDict()
             if not resources['metadata']['name']:
                 resources['metadata']['name'] = 'Notebook'
 
         #Set the output extension
         resources['output_extension'] = self.file_extension
         return resources
 
 
     def _preprocess(self, nb, resources):
         """
         Preprocess the notebook before passing it into the Jinja engine.
         To preprocess the notebook is to apply all of the
 
         Parameters
         ----------
         nb : notebook node
             notebook that is being exported.
         resources : a dict of additional resources that
             can be accessed read/write by preprocessors
         """
 
         # Do a copy.deepcopy first,
         # we are never safe enough with what the preprocessors could do.
         nbc =  copy.deepcopy(nb)
         resc = copy.deepcopy(resources)
 
         #Run each preprocessor on the notebook.  Carry the output along
         #to each preprocessor
         for preprocessor in self._preprocessors:
             nbc, resc = preprocessor(nbc, resc)
         return nbc, resc

IPython/nbconvert/preprocessors/__init__.py

@@ -1,13 +1,14 b''
 # Class base Preprocessors
 from .base import Preprocessor
 from .convertfigures import ConvertFiguresPreprocessor
 from .svg2pdf import SVG2PDFPreprocessor
 from .extractoutput import ExtractOutputPreprocessor
 from .revealhelp import RevealHelpPreprocessor
 from .latex import LatexPreprocessor
 from .csshtmlheader import CSSHTMLHeaderPreprocessor
 from .highlightmagics import HighlightMagicsPreprocessor
 from .clearoutput import ClearOutputPreprocessor
+from .execute import ExecutePreprocessor
 
 # decorated function Preprocessors
 from .coalescestreams import coalesce_streams