Merge pull request #3914 from jdfreder/trans_tests

nbconvert: Transformer tests

IPython/nbconvert/transformers/tests/base.py

@@ -0,0 +1,53
+"""
+Module with utility functions for transformer tests
+"""
+
+#-----------------------------------------------------------------------------
+# 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 IPython.nbformat import current as nbformat
+
+from ...tests.base import TestsBase
+from ...exporters.exporter import ResourcesDict
+
+#-----------------------------------------------------------------------------
+# Class
+#-----------------------------------------------------------------------------
+
+class TransformerTestsBase(TestsBase):
+    """Contains test functions transformer tests"""
+
+
+    def build_notebook(self):
+        """Build a notebook in memory for use with transformer tests"""
+
+        outputs = [nbformat.new_output(output_type="stream", stream="stdout", output_text="a"),
+                   nbformat.new_output(output_type="text", output_text="b"),
+                   nbformat.new_output(output_type="stream", stream="stdout", output_text="c"),
+                   nbformat.new_output(output_type="stream", stream="stdout", output_text="d"),
+                   nbformat.new_output(output_type="stream", stream="stderr", output_text="e"),
+                   nbformat.new_output(output_type="stream", stream="stderr", output_text="f"),
+                   nbformat.new_output(output_type="png", output_png=b'Zw==')] #g
+        
+        cells=[nbformat.new_code_cell(input="$ e $", prompt_number=1,outputs=outputs),
+               nbformat.new_text_cell('markdown', source="$ e $")]
+        worksheets = [nbformat.new_worksheet(name="worksheet1", cells=cells)]
+
+        return nbformat.new_notebook(name="notebook1", worksheets=worksheets)
+
+
+    def build_resources(self):
+        """Build an empty resources dictionary."""
+        
+        res = ResourcesDict()
+        res['metadata'] = ResourcesDict()
+        return res
  No newline at end of file

IPython/nbconvert/transformers/tests/test_coalescestreams.py

@@ -0,0 +1,38
+"""
+Module with tests for the coalescestreams transformer
+"""
+
+#-----------------------------------------------------------------------------
+# 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 .base import TransformerTestsBase
+from ..coalescestreams import coalesce_streams
+
+
+#-----------------------------------------------------------------------------
+# Class
+#-----------------------------------------------------------------------------
+
+class TestCoalesceStreams(TransformerTestsBase):
+    """Contains test functions for coalescestreams.py"""
+
+    def test_coalesce_streams(self):
+        """coalesce_streams transformer output test"""
+        nb = self.build_notebook()
+        res = self.build_resources()
+        nb, res = coalesce_streams(nb, res)
+        outputs = nb.worksheets[0].cells[0].outputs
+        self.assertEqual(outputs[0].text, "a")
+        self.assertEqual(outputs[1].output_type, "text")
+        self.assertEqual(outputs[2].text, "cd")
+        self.assertEqual(outputs[3].text, "ef")
+    
  No newline at end of file

IPython/nbconvert/transformers/tests/test_csshtmlheader.py

@@ -0,0 +1,47
+"""
+Module with tests for the csshtmlheader transformer
+"""
+
+#-----------------------------------------------------------------------------
+# 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 .base import TransformerTestsBase
+from ..csshtmlheader import CSSHTMLHeaderTransformer
+
+
+#-----------------------------------------------------------------------------
+# Class
+#-----------------------------------------------------------------------------
+
+class TestCSSHTMLHeader(TransformerTestsBase):
+    """Contains test functions for csshtmlheader.py"""
+
+
+    def build_transformer(self):
+        """Make an instance of a transformer"""
+        transformer = CSSHTMLHeaderTransformer()
+        transformer.enabled = True
+        return transformer
+
+
+    def test_constructor(self):
+        """Can a CSSHTMLHeaderTransformer be constructed?"""
+        self.build_transformer()
+    
+
+    def test_output(self):
+        """Test the output of the CSSHTMLHeaderTransformer"""
+        nb = self.build_notebook()
+        res = self.build_resources()
+        transformer = self.build_transformer()
+        nb, res = transformer(nb, res)
+        assert 'css' in res['inlining'] 
  No newline at end of file

IPython/nbconvert/transformers/tests/test_extractoutput.py

@@ -0,0 +1,62
+"""
+Module with tests for the extractoutput transformer
+"""
+
+#-----------------------------------------------------------------------------
+# 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 .base import TransformerTestsBase
+from ..extractoutput import ExtractOutputTransformer
+
+
+#-----------------------------------------------------------------------------
+# Class
+#-----------------------------------------------------------------------------
+
+class TestExtractOutput(TransformerTestsBase):
+    """Contains test functions for extractoutput.py"""
+
+
+    def build_transformer(self):
+        """Make an instance of a transformer"""
+        transformer = ExtractOutputTransformer()
+        transformer.enabled = True
+        return transformer
+
+
+    def test_constructor(self):
+        """Can a ExtractOutputTransformer be constructed?"""
+        self.build_transformer()
+    
+
+    def test_output(self):
+        """Test the output of the ExtractOutputTransformer"""
+        nb = self.build_notebook()
+        res = self.build_resources()
+        transformer = self.build_transformer()
+        nb, res = transformer(nb, res)
+
+        # Check if text was extracted.
+        assert 'text_filename' in nb.worksheets[0].cells[0].outputs[1]
+        text_filename = nb.worksheets[0].cells[0].outputs[1]['text_filename']
+
+        # Check if png was extracted.
+        assert 'png_filename' in nb.worksheets[0].cells[0].outputs[6]
+        png_filename = nb.worksheets[0].cells[0].outputs[6]['png_filename']
+
+        # Verify text output
+        assert text_filename in res['outputs']
+        self.assertEqual(res['outputs'][text_filename], b'b')
+
+        # Verify png output
+        assert png_filename in res['outputs']
+        self.assertEqual(res['outputs'][png_filename], b'g')

IPython/nbconvert/transformers/tests/test_latex.py

@@ -0,0 +1,51
+"""
+Module with tests for the latex transformer
+"""
+
+#-----------------------------------------------------------------------------
+# 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 .base import TransformerTestsBase
+from ..latex import LatexTransformer
+
+
+#-----------------------------------------------------------------------------
+# Class
+#-----------------------------------------------------------------------------
+
+class TestLatex(TransformerTestsBase):
+    """Contains test functions for latex.py"""
+
+
+    def build_transformer(self):
+        """Make an instance of a transformer"""
+        transformer = LatexTransformer()
+        transformer.enabled = True
+        return transformer
+
+    def test_constructor(self):
+        """Can a LatexTransformer be constructed?"""
+        self.build_transformer()
+        
+
+    def test_output(self):
+        """Test the output of the LatexTransformer"""
+        nb = self.build_notebook()
+        res = self.build_resources()
+        transformer = self.build_transformer()
+        nb, res = transformer(nb, res)
+
+        # Make sure the code cell wasn't modified.
+        self.assertEqual(nb.worksheets[0].cells[0].input, '$ e $')
+
+        # Verify that the markdown cell was processed.
+        self.assertEqual(nb.worksheets[0].cells[1].source, '$e$')

IPython/nbconvert/transformers/tests/test_revealhelp.py

@@ -0,0 +1,94
+"""
+Module with tests for the revealhelp transformer
+"""
+
+#-----------------------------------------------------------------------------
+# 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 IPython.nbformat import current as nbformat
+
+from .base import TransformerTestsBase
+from ..revealhelp import RevealHelpTransformer
+
+
+#-----------------------------------------------------------------------------
+# Class
+#-----------------------------------------------------------------------------
+
+class Testrevealhelp(TransformerTestsBase):
+    """Contains test functions for revealhelp.py"""
+
+    def build_notebook(self):
+        """Build a reveal slides notebook in memory for use with tests.  
+        Overrides base in TransformerTestsBase"""
+
+        outputs = [nbformat.new_output(output_type="stream", stream="stdout", output_text="a")]
+        
+        slide_metadata = {'slideshow' : {'slide_type': 'slide'}}
+        subslide_metadata = {'slideshow' : {'slide_type': 'subslide'}}
+
+        cells=[nbformat.new_code_cell(input="", prompt_number=1, outputs=outputs),
+               nbformat.new_text_cell('markdown', source="", metadata=slide_metadata),
+               nbformat.new_code_cell(input="", prompt_number=2, outputs=outputs),
+               nbformat.new_text_cell('markdown', source="", metadata=slide_metadata),
+               nbformat.new_text_cell('markdown', source="", metadata=subslide_metadata)]
+        worksheets = [nbformat.new_worksheet(name="worksheet1", cells=cells)]
+
+        return nbformat.new_notebook(name="notebook1", worksheets=worksheets)
+
+
+    def build_transformer(self):
+        """Make an instance of a transformer"""
+        transformer = RevealHelpTransformer()
+        transformer.enabled = True
+        return transformer
+
+
+    def test_constructor(self):
+        """Can a RevealHelpTransformer be constructed?"""
+        self.build_transformer()
+    
+
+    def test_reveal_attribute(self):
+        """Make sure the reveal url_prefix resources is set"""
+        nb = self.build_notebook()
+        res = self.build_resources()
+        transformer = self.build_transformer()
+        nb, res = transformer(nb, res)
+        assert 'reveal' in res
+        assert  'url_prefix' in res['reveal']
+
+
+    def test_reveal_output(self):
+        """Make sure that the reveal transformer """
+        nb = self.build_notebook()
+        res = self.build_resources()
+        transformer = self.build_transformer()
+        nb, res = transformer(nb, res)
+        cells = nb.worksheets[0].cells
+        
+        # Make sure correct metadata tags are available on every cell.
+        for cell in cells:
+            assert 'slide_type' in cell.metadata
+            assert 'align_type' in cell.metadata
+
+        # Make sure slide end is only applied to the cells preceeding slide 
+        # cells.
+        assert 'slide_helper' not in cells[1].metadata
+
+        # Verify 'slide-end'
+        assert 'slide_helper' in cells[0].metadata
+        self.assertEqual(cells[0].metadata['slide_helper'], 'slide_end')
+        assert 'slide_helper' in cells[2].metadata
+        self.assertEqual(cells[2].metadata['slide_helper'], 'slide_end')
+        assert 'slide_helper' in cells[3].metadata
+        self.assertEqual(cells[3].metadata['slide_helper'], 'subslide_end')

IPython/nbconvert/transformers/tests/test_sphinx.py

@@ -0,0 +1,57
+"""
+Module with tests for the sphinx transformer
+"""
+
+#-----------------------------------------------------------------------------
+# 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 .base import TransformerTestsBase
+from ..sphinx import SphinxTransformer
+
+
+#-----------------------------------------------------------------------------
+# Class
+#-----------------------------------------------------------------------------
+
+class TestSphinx(TransformerTestsBase):
+    """Contains test functions for sphinx.py"""
+
+
+    def build_transformer(self):
+        """Make an instance of a transformer"""
+        transformer = SphinxTransformer()
+        transformer.enabled = True
+        return transformer
+
+
+    def test_constructor(self):
+        """Can a SphinxTransformer be constructed?"""
+        self.build_transformer()
+    
+
+    def test_resources(self):
+        """Make sure the SphinxTransformer adds the appropriate resources to the
+        resources dict."""
+        nb = self.build_notebook()
+        res = self.build_resources()
+        transformer = self.build_transformer()
+        nb, res = transformer(nb, res)
+        assert "author" in res['sphinx']
+        assert "version" in res['sphinx']
+        assert "release" in res['sphinx']
+        assert "date" in res['sphinx']
+        assert "chapterstyle" in res['sphinx']
+        assert "outputstyle" in res['sphinx']
+        assert "centeroutput" in res['sphinx']
+        assert "header" in res['sphinx']
+        assert "texinputs" in res['sphinx']
+        assert "pygment_definitions" in res['sphinx']

IPython/nbconvert/transformers/tests/test_svg2pdf.py

@@ -0,0 +1,90
+"""
+Module with tests for the svg2pdf transformer
+"""
+
+#-----------------------------------------------------------------------------
+# 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 IPython.testing import decorators as dec
+from IPython.nbformat import current as nbformat
+
+from .base import TransformerTestsBase
+from ..svg2pdf import SVG2PDFTransformer
+
+
+#-----------------------------------------------------------------------------
+# Class
+#-----------------------------------------------------------------------------
+
+class Testsvg2pdf(TransformerTestsBase):
+    """Contains test functions for svg2pdf.py"""
+
+    simple_svg = """<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+<svg
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   version="1.0"
+   x="0.00000000"
+   y="0.00000000"
+   width="500.00000"
+   height="500.00000"
+   id="svg2">
+  <defs
+     id="defs4" />
+  <g
+     id="layer1">
+    <rect
+       width="300.00000"
+       height="300.00000"
+       x="100.00000"
+       y="100.00000"
+       style="opacity:1.0000000;fill:none;fill-opacity:1.0000000;fill-rule:evenodd;stroke:#000000;stroke-width:8.0000000;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4.0000000;stroke-dasharray:none;stroke-dashoffset:0.00000000;stroke-opacity:1.0000000"
+       id="rect5719" />
+  </g>
+</svg>"""
+
+    def build_notebook(self):
+        """Build a reveal slides notebook in memory for use with tests.  
+        Overrides base in TransformerTestsBase"""
+
+        outputs = [nbformat.new_output(output_type="svg", output_svg=self.simple_svg)]
+        
+        slide_metadata = {'slideshow' : {'slide_type': 'slide'}}
+        subslide_metadata = {'slideshow' : {'slide_type': 'subslide'}}
+
+        cells=[nbformat.new_code_cell(input="", prompt_number=1, outputs=outputs)]
+        worksheets = [nbformat.new_worksheet(name="worksheet1", cells=cells)]
+
+        return nbformat.new_notebook(name="notebook1", worksheets=worksheets)
+
+
+    def build_transformer(self):
+        """Make an instance of a transformer"""
+        transformer = SVG2PDFTransformer()
+        transformer.enabled = True
+        return transformer
+
+
+    def test_constructor(self):
+        """Can a SVG2PDFTransformer be constructed?"""
+        self.build_transformer()
+
+
+    @dec.onlyif_cmds_exist('inkscape')
+    def test_output(self):
+        """Test the output of the SVG2PDFTransformer"""
+        nb = self.build_notebook()
+        res = self.build_resources()
+        transformer = self.build_transformer()
+        nb, res = transformer(nb, res)
+        assert 'svg' in nb.worksheets[0].cells[0].outputs[0]

IPython/nbconvert/exporters/tests/test_exporter.py

@@ -1,112 +1,108
 """
 Module with tests for exporter.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 IPython.config import Config
 
 from .base import ExportersTestsBase
 from .cheese import CheeseTransformer
 from ..exporter import Exporter
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class TestExporter(ExportersTestsBase):
     """Contains test functions for exporter.py"""
 
 
     def test_constructor(self):
         """
         Can an Exporter be constructed?
         """
         Exporter()
 
 
     def test_export(self):
         """
         Can an Exporter export something?
         """
         exporter = self._make_exporter()
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert len(output) > 0
 
 
     def test_extract_outputs(self):
         """
         If the ExtractOutputTransformer is enabled, are outputs extracted?
         """
         config = Config({'ExtractOutputTransformer': {'enabled': True}})
         exporter = self._make_exporter(config=config)
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert resources is not None
-        assert 'outputs' in resources
+        assert isinstance(resources['outputs'], dict)
         assert len(resources['outputs']) > 0
 
 
     def test_transformer_class(self):
         """
         Can a transformer be added to the transformers list by class type?
         """
         config = Config({'Exporter': {'transformers': [CheeseTransformer]}})
         exporter = self._make_exporter(config=config)
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert resources is not None
-        assert 'cheese' in resources
         assert resources['cheese'] == 'real'
 
 
     def test_transformer_instance(self):
         """
         Can a transformer be added to the transformers list by instance?
         """
         config = Config({'Exporter': {'transformers': [CheeseTransformer()]}})
         exporter = self._make_exporter(config=config)
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert resources is not None
-        assert 'cheese' in resources
         assert resources['cheese'] == 'real'
 
 
     def test_transformer_dottedobjectname(self):
         """
         Can a transformer be added to the transformers list by dotted object name?
         """
         config = Config({'Exporter': {'transformers': ['IPython.nbconvert.exporters.tests.cheese.CheeseTransformer']}})
         exporter = self._make_exporter(config=config)
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert resources is not None
-        assert 'cheese' in resources
         assert resources['cheese'] == 'real'
 
 
     def test_transformer_via_method(self):
         """
         Can a transformer be added via the Exporter convenience method?
         """
         exporter = self._make_exporter()
         exporter.register_transformer(CheeseTransformer, enabled=True)
         (output, resources) = exporter.from_filename(self._get_notebook())
         assert resources is not None
-        assert 'cheese' in resources
         assert resources['cheese'] == 'real'
 
 
     def _make_exporter(self, config=None):
         #Create the exporter instance, make sure to set a template name since
         #the base Exporter doesn't have a template associated with it.
         exporter = Exporter(config=config, template_file='python')
         return exporter        
  No newline at end of file

IPython/nbconvert/transformers/extractoutput.py

@@ -1,101 +1,102
 """Module containing a transformer that extracts all of the outputs from the
 notebook file.  The extracted outputs are returned in the 'resources' dictionary.
 """
 #-----------------------------------------------------------------------------
 # 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
 #-----------------------------------------------------------------------------
 
 import base64
 import sys
 import os
 
 from IPython.utils.traitlets import Unicode
 from .base import Transformer
 from IPython.utils import py3compat
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class ExtractOutputTransformer(Transformer):
     """
     Extracts all of the outputs from the notebook file.  The extracted 
     outputs are returned in the 'resources' dictionary.
     """
 
     output_filename_template = Unicode(
         "{unique_key}_{cell_index}_{index}.{extension}", config=True)
 
 
     def transform_cell(self, cell, resources, cell_index):
         """
         Apply a transformation on each cell,
         
         Parameters
         ----------
         cell : NotebookNode cell
             Notebook cell being processed
         resources : dictionary
             Additional resources used in the conversion process.  Allows
             transformers to pass variables into the Jinja engine.
         cell_index : int
             Index of the cell being processed (see base.py)
         """
 
         #Get the unique key from the resource dict if it exists.  If it does not 
         #exist, use 'output' as the default.  Also, get files directory if it
         #has been specified
         unique_key = resources.get('unique_key', 'output')
         output_files_dir = resources.get('output_files_dir', None)
         
         #Make sure outputs key exists
-        if not 'outputs' in resources:
+        if not isinstance(resources['outputs'], dict):
             resources['outputs'] = {}
             
         #Loop through all of the outputs in the cell
         for index, out in enumerate(cell.get('outputs', [])):
 
             #Get the output in data formats that the template is interested in.
             for out_type in self.display_data_priority:
                 if out.hasattr(out_type):
                     data = out[out_type]
 
                     #Binary files are base64-encoded, SVG is already XML
                     if out_type in ('png', 'jpg', 'jpeg', 'pdf'):
+
                         # data is b64-encoded as text (str, unicode)
                         # decodestring only accepts bytes
                         data = py3compat.cast_bytes(data)
                         data = base64.decodestring(data)
                     elif sys.platform == 'win32':
                         data = data.replace('\n', '\r\n').encode("UTF-8")
                     else:
                         data = data.encode("UTF-8")
                     
                     #Build an output name
                     filename = self.output_filename_template.format( 
                                     unique_key=unique_key,
                                     cell_index=cell_index,
                                     index=index,
                                     extension=out_type)
 
                     #On the cell, make the figure available via 
                     #   cell.outputs[i].svg_filename  ... etc (svg in example)
                     # Where
                     #   cell.outputs[i].svg  contains the data
                     if output_files_dir is not None:
                         filename = os.path.join(output_files_dir, filename)
                     out[out_type + '_filename'] = filename
 
                     #In the resources, make the figure available via
                     #   resources['outputs']['filename'] = data
                     resources['outputs'][filename] = data
 
         return cell, resources

IPython/nbconvert/transformers/revealhelp.py

@@ -1,61 +1,61
 """Module that pre-processes the notebook for export via Reveal.
 """
 #-----------------------------------------------------------------------------
 # 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 .base import Transformer
 from IPython.utils.traitlets import Unicode
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 class RevealHelpTransformer(Transformer):
 
     url_prefix = Unicode('//cdn.jsdelivr.net/reveal.js/2.4.0',
                          config=True,
                          help="""If you want to use a local reveal.js library,
                          use 'url_prefix':'reveal.js' in your config object.""")
 
     def call(self, nb, resources):
         """
         Called once to 'transform' contents of the notebook.
 
         Parameters
         ----------
         nb : NotebookNode
             Notebook being converted
         resources : dictionary
             Additional resources used in the conversion process.  Allows
             transformers to pass variables into the Jinja engine.
         """
 
         for worksheet in nb.worksheets :
             for index, cell in enumerate(worksheet.cells):
 
                 #Make sure the cell has slideshow metadata.
                 cell.metadata.align_type = cell.get('metadata', {}).get('slideshow', {}).get('align_type', 'Left')
                 cell.metadata.slide_type = cell.get('metadata', {}).get('slideshow', {}).get('slide_type', '-')
 
                 #Get the slide type.  If type is start of subslide or slide,
                 #end the last subslide/slide.
                 if cell.metadata.slide_type in ['slide']:
                     worksheet.cells[index - 1].metadata.slide_helper = 'slide_end'
                 if cell.metadata.slide_type in ['subslide']:
                     worksheet.cells[index - 1].metadata.slide_helper = 'subslide_end'
 
 
-        if 'reveal' not in resources:
+        if not isinstance(resources['reveal'], dict):
             resources['reveal'] = {}
         resources['reveal']['url_prefix'] = self.url_prefix
 
         return nb, resources

IPython/nbconvert/transformers/sphinx.py

@@ -1,264 +1,264
 """Module that allows custom Sphinx parameters to be set on the notebook and
 on the 'other' object passed into Jinja.  Called prior to Jinja conversion
 process.
 """
 #-----------------------------------------------------------------------------
 # 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 os.path
 
 # Used to set the default date to today's date 
 from datetime import date 
 
 # Third-party imports
 # Needed for Pygments latex definitions.
 from pygments.formatters import LatexFormatter
 
 # Our own imports
 # Configurable traitlets
 from IPython.utils.traitlets import Unicode, Bool
 
 # Needed to override transformer
 from .base import (Transformer)
 
 from IPython.nbconvert.utils import console  
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 class SphinxTransformer(Transformer):
     """
     Sphinx utility transformer.
 
     This transformer is used to set variables needed by the latex to build
     Sphinx stylized templates.
     """
     
     interactive = Bool(False, config=True, help="""
         Allows you to define whether or not the Sphinx exporter will prompt
         you for input during the conversion process.  If this is set to false,
         the author, version, release, date, and chapter_style traits should
         be set.
         """)
     
     author = Unicode("Unknown Author", config=True, help="Author name")
     
     version = Unicode("", config=True, help="""
         Version number
         You can leave this blank if you do not want to render a version number.
         Example: "1.0.0"
         """)
     
     release = Unicode("", config=True, help="""
         Release name
         You can leave this blank if you do not want to render a release name.
         Example: "Rough Draft"
         """)
     
     publish_date = Unicode("", config=True, help="""
         Publish date
         This is the date to render on the document as the publish date.
         Leave this blank to default to todays date.  
         Example: "June 12, 1990"
         """)
     
     chapter_style = Unicode("Bjarne", config=True, help="""
         Sphinx chapter style
         This is the style to use for the chapter headers in the document.
         You may choose one of the following:
             "Bjarne"    (default)
             "Lenny"
             "Glenn"
             "Conny"
             "Rejne"
             "Sonny"    (used for international documents)
         """)
     
     output_style = Unicode("notebook", config=True, help="""
         Nbconvert Ipython
         notebook input/output formatting style.
         You may choose one of the following:
             "simple     (recommended for long code segments)"
             "notebook"  (default)
         """)
     
     center_output = Bool(False, config=True, help="""
         Optional attempt to center all output.  If this is false, no additional
         formatting is applied.
         """)
     
     use_headers = Bool(True, config=True, help="""
         Whether not a header should be added to the document.
         """)
     
     #Allow the user to override the title of the notebook (useful for
     #fancy document titles that the file system doesn't support.)
     overridetitle = Unicode("", config=True, help="")
 
     
     def call(self, nb, resources):
         """
         Sphinx transformation to apply on each notebook.
         
         Parameters
         ----------
         nb : NotebookNode
             Notebook being converted
         resources : dictionary
             Additional resources used in the conversion process.  Allows
             transformers to pass variables into the Jinja engine.
         """
         # import sphinx here, so that sphinx is not a dependency when it's not used
         import sphinx
          
         # TODO: Add versatile method of additional notebook metadata.  Include
         #       handling of multiple files.  For now use a temporay namespace,
         #       '_draft' to signify that this needs to change.
-        if not "sphinx" in resources:
+        if not isinstance(resources["sphinx"], dict):
             resources["sphinx"] = {}
 
         if self.interactive:
             
             # Prompt the user for additional meta data that doesn't exist currently
             # but would be usefull for Sphinx.
             resources["sphinx"]["author"] = self._prompt_author()
             resources["sphinx"]["version"] = self._prompt_version()
             resources["sphinx"]["release"] = self._prompt_release()
             resources["sphinx"]["date"] = self._prompt_date()
             
             # Prompt the user for the document style.
             resources["sphinx"]["chapterstyle"] = self._prompt_chapter_title_style()
             resources["sphinx"]["outputstyle"] = self._prompt_output_style()
             
             # Small options
             resources["sphinx"]["centeroutput"] = console.prompt_boolean("Do you want to center the output? (false)", False)
             resources["sphinx"]["header"] = console.prompt_boolean("Should a Sphinx document header be used? (true)", True)
         else:
             
             # Try to use the traitlets.
             resources["sphinx"]["author"] = self.author
             resources["sphinx"]["version"] = self.version
             resources["sphinx"]["release"] = self.release
             
             # Use todays date if none is provided.
             if self.publish_date:
                 resources["sphinx"]["date"] = self.publish_date
             elif len(resources['metadata']['modified_date'].strip()) == 0:
                 resources["sphinx"]["date"] = date.today().strftime("%B %-d, %Y")
             else:
                 resources["sphinx"]["date"] = resources['metadata']['modified_date']
             
             # Sphinx traitlets.
             resources["sphinx"]["chapterstyle"] = self.chapter_style
             resources["sphinx"]["outputstyle"] = self.output_style
             resources["sphinx"]["centeroutput"] = self.center_output
             resources["sphinx"]["header"] = self.use_headers
             
         # Find and pass in the path to the Sphinx dependencies.
         resources["sphinx"]["texinputs"] = os.path.realpath(os.path.join(sphinx.package_dir, "texinputs"))
         
         # Generate Pygments definitions for Latex 
         resources["sphinx"]["pygment_definitions"] = self._generate_pygments_latex_def()
         
         if not (self.overridetitle == None or len(self.overridetitle.strip()) == 0):
             resources['metadata']['name'] = self.overridetitle
         
         # End
         return nb, resources 
     
     
     def _generate_pygments_latex_def(self):
         """
         Generate the pygments latex definitions that allows pygments
         to work in latex.
         """
         
         return LatexFormatter().get_style_defs()       
     
     
     def _prompt_author(self):
         """
         Prompt the user to input an Author name
         """
         return  console.input("Author name: ")
     
     
     def _prompt_version(self):
         """
         prompt the user to enter a version number
         """
         return  console.input("Version (ie ""1.0.0""): ")
     
     
     def _prompt_release(self):
         """
         Prompt the user to input a release name
         """
         
         return  console.input("Release Name (ie ""Rough draft""): ")
     
     
     def _prompt_date(self, resources):
         """
         Prompt the user to enter a date
         """
         
         if resources['metadata']['modified_date']:
             default_date = resources['metadata']['modified_date']
         else:
             default_date = date.today().strftime("%B %-d, %Y")
             
         user_date = console.input("Date (deafults to \"" + default_date + "\"): ")
         if len(user_date.strip()) == 0:
             user_date = default_date
         return user_date
     
     
     def _prompt_output_style(self):
         """
         Prompts the user to pick an IPython output style.
         """
         
         # Dictionary of available output styles
         styles = {1: "simple",
                   2: "notebook"}
         
         #Append comments to the menu when displaying it to the user.
         comments = {1: "(recommended for long code segments)",
                     2: "(default)"}
         
         return console.prompt_dictionary(styles, default_style=2, menu_comments=comments)
     
     
     def _prompt_chapter_title_style(self):
         """
         Prompts the user to pick a Sphinx chapter style
         """
         
         # Dictionary of available Sphinx styles
         styles = {1: "Bjarne",
                   2: "Lenny",
                   3: "Glenn",
                   4: "Conny",
                   5: "Rejne",
                   6: "Sonny"}
         
         #Append comments to the menu when displaying it to the user.
         comments = {1: "(default)",
                     6: "(for international documents)"}
         
         return console.prompt_dictionary(styles, menu_comments=comments)
 

IPython/nbconvert/writers/debug.py

@@ -1,42 +1,42
 """
 Contains debug writer.
 """
 #-----------------------------------------------------------------------------
 #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 .base import WriterBase
 from pprint import pprint
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class DebugWriter(WriterBase):
     """Consumes output from nbconvert export...() methods and writes usefull
     debugging information to the stdout.  The information includes a list of
     resources that were extracted from the notebook(s) during export."""
 
 
     def write(self, output, resources, notebook_name='notebook', **kw):
         """
         Consume and write Jinja output.
 
         See base for more...
         """
 
-        if 'outputs' in resources:
+        if isinstance(resources['outputs'], dict):
             print("outputs extracted from %s" % notebook_name)
             print('-' * 80)
             pprint(resources['outputs'], indent=2, width=70)
         else:
             print("no outputs extracted from %s" % notebook_name)
         print('=' * 80)