HTML-Slides -> Slides-Reveal

IPython/nbconvert/exporters/slides.py

@@ -0,0 +1,52 b''
+"""
+Exporter that exports Basic HTML.
+"""
+
+#-----------------------------------------------------------------------------
+# 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.utils.traitlets import Unicode
+
+from IPython.nbconvert import transformers
+from IPython.config import Config
+
+from .exporter import Exporter
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class SlidesExporter(Exporter):
+    """
+    Exports slides
+    """
+    
+    file_extension = Unicode(
+        'html', config=True, 
+        help="Extension of the file that should be written to disk"
+        )
+
+    flavor = Unicode('reveal', config=True, help="""Flavor of the data format to 
+        use.  I.E. 'reveal'""")
+
+    @property
+    def default_config(self):
+        c = Config({
+            'CSSHTMLHeaderTransformer':{
+                'enabled':True
+                },
+            'RevealHelpTransformer':{
+                'enabled':True,
+                },                
+            })
+        c.merge(super(SlidesExporter,self).default_config)
+        return c

IPython/nbconvert/exporters/tests/test_slides.py

@@ -0,0 +1,47 b''
+"""
+Module with tests for slides.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 .base import ExportersTestsBase
+from ..slides import SlidesExporter
+
+#-----------------------------------------------------------------------------
+# Class
+#-----------------------------------------------------------------------------
+
+class TestSlidesExporter(ExportersTestsBase):
+    """Contains test functions for slides.py"""
+
+    def test_constructor(self):
+        """
+        Can a SlidesExporter be constructed?
+        """
+        SlidesExporter()
+
+
+    def test_export(self):
+        """
+        Can a SlidesExporter export something?
+        """
+        (output, resources) = SlidesExporter().from_filename(self._get_notebook())
+        assert len(output) > 0
+
+
+    def test_export_reveal(self):
+        """
+        Can a SlidesExporter export using the 'reveal' flavor?
+        """
+        (output, resources) = SlidesExporter(flavor='reveal').from_filename(self._get_notebook())
+        assert len(output) > 0

IPython/nbconvert/exporters/__init__.py

@@ -1,7 +1,8 b''
-from .html import HTMLExporter
 from .export import *
+from .html import HTMLExporter
+from .slides import SlidesExporter
 from .exporter import Exporter
 from .latex import LatexExporter
 from .markdown import MarkdownExporter
 from .python import PythonExporter
 from .rst import RSTExporter

IPython/nbconvert/exporters/export.py

@@ -1,195 +1,205 b''
 """
 Module containing single call export functions.
 """
 #-----------------------------------------------------------------------------
 # 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 functools import wraps
 
 from IPython.nbformat.v3.nbbase import NotebookNode
 from IPython.config import Config
 
 from .exporter import Exporter
 from .html import HTMLExporter
+from .slides import SlidesExporter
 from .latex import LatexExporter
 from .markdown import MarkdownExporter
 from .python import PythonExporter
 from .rst import RSTExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 def DocDecorator(f):
     
     #Set docstring of function
     f.__doc__ = f.__doc__ + """
     nb : Notebook node
     config : config (optional, keyword arg)
         User configuration instance.
     resources : dict (optional, keyword arg)
         Resources used in the conversion process.
         
     Returns
     ----------
     tuple- output, resources, exporter_instance
     output : str
         Jinja 2 output.  This is the resulting converted notebook.
     resources : dictionary
         Dictionary of resources used prior to and during the conversion 
         process.
     exporter_instance : Exporter
         Instance of the Exporter class used to export the document.  Useful
         to caller because it provides a 'file_extension' property which
         specifies what extension the output should be saved as."""
             
     @wraps(f)
     def decorator(*args, **kwargs):
         return f(*args, **kwargs)
     
     return decorator
 
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 __all__ = [
     'export',
     'export_html',
     'export_custom',
+    'export_slides',
     'export_latex',
     'export_markdown',
     'export_python',
     'export_rst',
     'export_by_name',
     'get_export_names',
     'ExporterNameError'
 ]
 
 
 class ExporterNameError(NameError):
     pass
 
 
 @DocDecorator
 def export(exporter, nb, **kw):
     """
     Export a notebook object using specific exporter class.
     
     exporter : Exporter class type or instance
         Class type or instance of the exporter that should be used.  If the 
         method initializes it's own instance of the class, it is ASSUMED that 
         the class type provided exposes a constructor (__init__) with the same 
         signature as the base Exporter class.
     """
     
     #Check arguments
     if exporter is None:
         raise TypeError("Exporter is None")
     elif not isinstance(exporter, Exporter) and not issubclass(exporter, Exporter):
         raise TypeError("exporter does not inherit from Exporter (base)")
     if nb is None:
         raise TypeError("nb is None")
     
     #Create the exporter
     resources = kw.pop('resources', None)
     if isinstance(exporter, Exporter):
         exporter_instance = exporter
     else:
         exporter_instance = exporter(**kw)
 
     #Try to convert the notebook using the appropriate conversion function.
     if isinstance(nb, NotebookNode):
         output, resources = exporter_instance.from_notebook_node(nb, resources)
     elif isinstance(nb, basestring):
         output, resources = exporter_instance.from_filename(nb, resources)
     else:
         output, resources = exporter_instance.from_file(nb, resources)
     return output, resources
 
 
 @DocDecorator
 def export_custom(nb, **kw):
     """
     Export a notebook object to a custom format
     """
     return export(Exporter, nb, **kw)
 
 
 @DocDecorator
 def export_html(nb, **kw):
     """
     Export a notebook object to HTML
     """
     return export(HTMLExporter, nb, **kw)
 
 
 @DocDecorator
+def export_slides(nb, **kw):
+    """
+    Export a notebook object to Slides
+    """
+    return export(SlidesExporter, nb, **kw)
+
+
+@DocDecorator
 def export_latex(nb, **kw):
     """
     Export a notebook object to LaTeX
     """
     return export(LatexExporter, nb, **kw)
 
 
 @DocDecorator
 def export_markdown(nb, **kw):
     """
     Export a notebook object to Markdown
     """
     return export(MarkdownExporter, nb, **kw)
 
 
 @DocDecorator
 def export_python(nb, **kw):
     """
     Export a notebook object to Python
     """
     return export(PythonExporter, nb, **kw)
 
 
 @DocDecorator
 def export_rst(nb, **kw):
     """
     Export a notebook object to reStructuredText
     """
     return export(RSTExporter, nb, **kw)
 
 
 @DocDecorator
 def export_by_name(format_name, nb, **kw):
     """
     Export a notebook object to a template type by its name.  Reflection
     (Inspect) is used to find the template's corresponding explicit export
     method defined in this module.  That method is then called directly.
     
     format_name : str
         Name of the template style to export to.
     """
     
     function_name = "export_" + format_name.lower()
     
     if function_name in globals():
         return globals()[function_name](nb, **kw)
     else:
         raise ExporterNameError("template for `%s` not found" % function_name)
 
 
 def get_export_names():
     "Return a list of the currently supported export targets"
     # grab everything after 'export_'
     l = [x[len('export_'):] for x in __all__ if x.startswith('export_')]
     
     # filter out the one method that is not a template
     l = [x for x in l if 'by_name' not in x]
     return sorted(l)

IPython/nbconvert/exporters/tests/test_html.py

@@ -1,64 +1,56 b''
 """
-Module with tests for basichtml.py
+Module with tests for html.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 .base import ExportersTestsBase
 from ..html import HTMLExporter
 from IPython.testing.decorators import onlyif_cmds_exist
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class TestHTMLExporter(ExportersTestsBase):
-    """Contains test functions for basichtml.py"""
+    """Contains test functions for html.py"""
 
     def test_constructor(self):
         """
         Can a HTMLExporter be constructed?
         """
         HTMLExporter()
 
     @onlyif_cmds_exist('pandoc')
     def test_export(self):
         """
         Can a HTMLExporter export something?
         """
         (output, resources) = HTMLExporter().from_filename(self._get_notebook())
         assert len(output) > 0
 
 
     def test_export_basic(self):
         """
         Can a HTMLExporter export using the 'basic' flavor?
         """
         (output, resources) = HTMLExporter(flavor='basic').from_filename(self._get_notebook())
         assert len(output) > 0
 
 
     def test_export_full(self):
         """
         Can a HTMLExporter export using the 'full' flavor?
         """
         (output, resources) = HTMLExporter(flavor='full').from_filename(self._get_notebook())
         assert len(output) > 0
-
-
-    def test_export_reveal(self):
-        """
-        Can a HTMLExporter export using the 'reveal' flavor?
-        """
-        (output, resources) = HTMLExporter(flavor='reveal').from_filename(self._get_notebook())
-        assert len(output) > 0
  No newline at end of file

IPython/nbconvert/nbconvertapp.py

@@ -1,259 +1,259 b''
 #!/usr/bin/env python
 """NBConvert is a utility for conversion of .ipynb files.
 
 Command-line interface for the NbConvert conversion utility.
 """
 #-----------------------------------------------------------------------------
 #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
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 from __future__ import print_function
 import sys
 import os
 import glob
 
 # From IPython
 from IPython.core.application import BaseIPythonApplication, base_aliases, base_flags
 from IPython.config import catch_config_error, Configurable
 from IPython.utils.traitlets import (
     Unicode, List, Instance, DottedObjectName, Type, CaselessStrEnum,
 )
 from IPython.utils.importstring import import_item
 
 from .exporters.export import export_by_name, get_export_names, ExporterNameError
 from IPython.nbconvert import exporters, transformers, writers
 from .utils.base import NbConvertBase
 from .utils.exceptions import ConversionException
 
 #-----------------------------------------------------------------------------
 #Classes and functions
 #-----------------------------------------------------------------------------
 
 nbconvert_aliases = {}
 nbconvert_aliases.update(base_aliases)
 nbconvert_aliases.update({
     'to' : 'NbConvertApp.export_format',
     'flavor' : 'Exporter.flavor',
     'template' : 'Exporter.template_file',
     'notebooks' : 'NbConvertApp.notebooks',
     'writer' : 'NbConvertApp.writer_class',
 })
 
 nbconvert_flags = {}
 nbconvert_flags.update(base_flags)
 nbconvert_flags.update({
     'stdout' : (
         {'NbConvertApp' : {'writer_class' : "StdoutWriter"}},
         "Write notebook output to stdout instead of files."
         ),
 
     'pdf' : (
         {'NbConvertApp' : {'writer_class' : "PDFWriter"}},
         "Compile notebook output to a PDF."
         )
 })
 
 
 class NbConvertApp(BaseIPythonApplication):
     """Application used to convert to and from notebook file type (*.ipynb)"""
 
     name = 'ipython-nbconvert'
     aliases = nbconvert_aliases
     flags = nbconvert_flags
     
     def _classes_default(self):
         classes = [NbConvertBase]
         for pkg in (exporters, transformers, writers):
             for name in dir(pkg):
                 cls = getattr(pkg, name)
                 if isinstance(cls, type) and issubclass(cls, Configurable):
                     classes.append(cls)
         return classes
 
     description = Unicode(
         u"""This application is used to convert notebook files (*.ipynb)
         to various other formats.""")
 
     examples = Unicode(u"""
         The simplest way to use nbconvert is
         
         > ipython nbconvert mynotebook.ipynb
         
         which will convert mynotebook.ipynb to the default format (probably HTML).
         
         You can specify the export format with `--to`.
         Options include {0}
         
         > ipython nbconvert --to latex mynotebook.ipnynb
 
         Both HTML and LaTeX support multiple flavors of output. LaTeX includes
-        'basic', 'book', and 'article'.  HTML includes 'basic', 'full', and 
-        'reveal'.  You can specify the flavor of the format used.
+        'basic', 'book', and 'article'.  HTML includes 'basic' and 'full'.  You 
+        can specify the flavor of the format used.
 
         > ipython nbconvert --to html --flavor reveal mynotebook.ipnynb
         
         You can also pipe the output to stdout, rather than a file
         
         > ipython nbconvert mynotebook.ipynb --stdout
 
         or to a PDF
 
         > ipython nbconvert mynotebook.ipynb --pdf
         
         Multiple notebooks can be given at the command line in a couple of 
         different ways:
   
         > ipython nbconvert notebook*.ipynb
         > ipython nbconvert notebook1.ipynb notebook2.ipynb
         
         or you can specify the notebooks list in a config file, containing::
         
             c.NbConvertApp.notebooks = ["my_notebook.ipynb"]
         
         > ipython nbconvert --config mycfg.py
         """.format(get_export_names()))
     # Writer specific variables
     writer = Instance('IPython.nbconvert.writers.base.WriterBase',  
                       help="""Instance of the writer class used to write the 
                       results of the conversion.""")
     writer_class = DottedObjectName('FilesWriter', config=True, 
                                     help="""Writer class used to write the 
                                     results of the conversion""")
     writer_aliases = {'FilesWriter': 'IPython.nbconvert.writers.files.FilesWriter',
                       'PDFWriter': 'IPython.nbconvert.writers.pdf.PDFWriter',
                       'DebugWriter': 'IPython.nbconvert.writers.debug.DebugWriter',
                       'StdoutWriter': 'IPython.nbconvert.writers.stdout.StdoutWriter'}
     writer_factory = Type()
 
     def _writer_class_changed(self, name, old, new):
         if new in self.writer_aliases:
             new = self.writer_aliases[new]
         self.writer_factory = import_item(new)
 
 
     # Other configurable variables
     export_format = CaselessStrEnum(get_export_names(),
         default_value="html",
         config=True,
         help="""The export format to be used."""
     )
 
     notebooks = List([], config=True, help="""List of notebooks to convert.
                      Wildcards are supported.
                      Filenames passed positionally will be added to the list.
                      """)
 
     @catch_config_error
     def initialize(self, argv=None):
         super(NbConvertApp, self).initialize(argv)
         self.init_syspath()
         self.init_notebooks()
         self.init_writer()
 
 
     def init_syspath(self):
         """
         Add the cwd to the sys.path ($PYTHONPATH)
         """
         sys.path.insert(0, os.getcwd())
         
 
     def init_notebooks(self):
         """Construct the list of notebooks.
         If notebooks are passed on the command-line,
         they override notebooks specified in config files.
         Glob each notebook to replace notebook patterns with filenames.
         """
 
         # Specifying notebooks on the command-line overrides (rather than adds)
         # the notebook list
         if self.extra_args:
             patterns = self.extra_args
         else:
             patterns = self.notebooks
 
         # Use glob to replace all the notebook patterns with filenames.
         filenames = []
         for pattern in patterns:
             
             # Use glob to find matching filenames.  Allow the user to convert 
             # notebooks without having to type the extension.
             globbed_files = glob.glob(pattern)
             globbed_files.extend(glob.glob(pattern + '.ipynb'))
 
             for filename in globbed_files:
                 if not filename in filenames:
                     filenames.append(filename)
         self.notebooks = filenames
 
     def init_writer(self):
         """
         Initialize the writer (which is stateless)
         """
         self._writer_class_changed(None, self.writer_class, self.writer_class)
         self.writer = self.writer_factory(parent=self)
 
     def start(self):
         """
         Ran after initialization completed
         """
         super(NbConvertApp, self).start()
         self.convert_notebooks()
 
     def convert_notebooks(self):
         """
         Convert the notebooks in the self.notebook traitlet
         """
         # Export each notebook
         conversion_success = 0
         for notebook_filename in self.notebooks:
 
             # Get a unique key for the notebook and set it in the resources object.
             basename = os.path.basename(notebook_filename)
             notebook_name = basename[:basename.rfind('.')]
             resources = {}
             resources['unique_key'] = notebook_name
             resources['output_files_dir'] = '%s_files' % notebook_name
 
             # Try to export
             try:
                 output, resources = export_by_name(self.export_format,
                                               notebook_filename, 
                                               resources=resources,
                                               config=self.config)
             except ExporterNameError as e:
                 print("Error while converting '%s': '%s' exporter not found."
                       %(notebook_filename, self.export_format),
                       file=sys.stderr)
                 print("Known exporters are:",
                       "\n\t" + "\n\t".join(get_export_names()),
                       file=sys.stderr)
                 self.exit(1)
             except ConversionException as e:
                 print("Error while converting '%s': %s" %(notebook_filename, e),
                       file=sys.stderr)
                 self.exit(1)
             else:
                 self.writer.write(output, resources, notebook_name=notebook_name)
                 conversion_success += 1
 
         # If nothing was converted successfully, help the user.
         if conversion_success == 0:
             self.print_help()
             sys.exit(-1)
 
 
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 launch_new_instance = NbConvertApp.launch_instance

IPython/nbconvert/tests/test_nbconvertapp.py

@@ -1,135 +1,135 b''
 """
 Contains tests for the nbconvertapp
 """
 #-----------------------------------------------------------------------------
 #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 os
 from .base import TestsBase
 
 from IPython.utils import py3compat
 
     
 #-----------------------------------------------------------------------------
 # Constants
 #-----------------------------------------------------------------------------
 
 # Define ipython commandline name
 if py3compat.PY3:
     IPYTHON = 'ipython3'
 else:
     IPYTHON = 'ipython'
 
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 class TestNbConvertApp(TestsBase):
     """Collection of NbConvertApp tests"""
 
 
     def test_notebook_help(self):
         """
         Will help show if no notebooks are specified?
         """
         with self.create_temp_cwd():
             assert "see '--help-all'" in self.call([IPYTHON, 'nbconvert'])
 
 
     def test_glob(self):
         """
         Do search patterns work for notebook names?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
             assert not 'error' in self.call([IPYTHON, 'nbconvert', 
                 '--to="python"', '--notebooks=["*.ipynb"]']).lower()
             assert os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_glob_subdir(self):
         """
         Do search patterns work for subdirectory notebook names?
         """
         with self.create_temp_cwd() as cwd:
             self.copy_files_to(['notebook*.ipynb'], 'subdir/')
             assert not 'error' in self.call([IPYTHON, 'nbconvert', '--to="python"', 
                 '--notebooks=["%s"]' % os.path.join('subdir', '*.ipynb')]).lower()
             assert os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_explicit(self):
         """
         Do explicit notebook names work?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
             assert not 'error' in self.call([IPYTHON, 'nbconvert', '--to="python"', 
                 '--notebooks=["notebook2.ipynb"]']).lower()
             assert not os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_flavor(self):
         """
-        Do explicit notebook names work?
+        Do export flavors work?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
-            assert not 'error' in self.call([IPYTHON, 'nbconvert', '--to="html"', 
+            assert not 'error' in self.call([IPYTHON, 'nbconvert', '--to="slides"', 
                 '--notebooks=["notebook2.ipynb"]', '--flavor="reveal"']).lower()
             assert os.path.isfile('notebook2.html')
             with open('notebook2.html') as f:
                 assert '/reveal.css' in f.read()
 
 
     def test_glob_explicit(self):
         """
         Can a search pattern be used along with matching explicit notebook names?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
             assert not 'error' in self.call([IPYTHON, 'nbconvert', '--to="python"', 
                 '--notebooks=["*.ipynb", "notebook1.ipynb", "notebook2.ipynb"]']).lower()
             assert os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_explicit_glob(self):
         """
         Can explicit notebook names be used and then a matching search pattern?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
             assert not 'error' in self.call([IPYTHON, 'nbconvert', '--to="python"', 
                 '--notebooks=["notebook1.ipynb", "notebook2.ipynb", "*.ipynb"]']).lower()
             assert os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_default_config(self):
         """
         Does the default config work?
         """
         with self.create_temp_cwd(['notebook*.ipynb', 'ipython_nbconvert_config.py']):
             assert not 'error' in self.call([IPYTHON, 'nbconvert']).lower()
             assert os.path.isfile('notebook1.py')
             assert not os.path.isfile('notebook2.py')
 
 
     def test_override_config(self):
         """
         Can the default config be overriden?
         """
         with self.create_temp_cwd(['notebook*.ipynb', 'ipython_nbconvert_config.py', 
                                    'override.py']):
             assert not 'error' in self.call([IPYTHON, 'nbconvert', '--config="override.py"']).lower()
             assert not os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')