nbconvert/export.py

"""
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
#-----------------------------------------------------------------------------

import sys
import inspect

from IPython.nbformat.v3.nbbase import NotebookNode

from .exporters.exporter import Exporter
from .exporters.basichtml import BasicHtmlExporter
from .exporters.fullhtml import FullHtmlExporter
from .exporters.latex import LatexExporter
from .exporters.markdown import MarkdownExporter
from .exporters.python import PythonExporter
from .exporters.python_armor import PythonArmorExporter
from .exporters.reveal import RevealExporter
from .exporters.rst import RstExporter
from .exporters.sphinx_howto import SphinxHowtoExporter
from .exporters.sphinx_manual import SphinxManualExporter


#-----------------------------------------------------------------------------
# Functions
#-----------------------------------------------------------------------------

def export(nb, config=None, transformers=None, filters=None, exporter_type=Exporter):
    """
    Export a notebook object using specific exporter class.
    
    Parameters
    ----------
    config : config
        User configuration instance.
    transformers : list[of transformer]
        Custom transformers to apply to the notebook prior to engaging
        the Jinja template engine.  Any transformers specified here 
        will override existing transformers if a naming conflict
        occurs.
    filters : list[of filter]
        Custom filters to make accessible to the Jinja templates.  Any
        filters specified here will override existing filters if a
        naming conflict occurs.
    exporter_type:
        Class type of the exporter that should be used.  This method
        will initialize 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.
        
    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.
    """
    
    #Check arguments
    if exporter_type is None:
        raise TypeError("Exporter is None")
    elif not issubclass(exporter_type, Exporter):
        raise TypeError("Exporter type does not inherit from Exporter (base)")
    
    if nb is None:
        raise TypeError("nb is None")
    
    #Create the exporter
    exporter_instance = exporter_type(preprocessors=transformers, 
                                      jinja_filters=filters, config=config)

    #Try to convert the notebook using the appropriate conversion function.
    if isinstance(nb, NotebookNode):
        output, resources = exporter_instance.from_notebook_node(nb)
    elif isinstance(nb, basestring):
        output, resources = exporter_instance.from_filename(nb)
    else:
        output, resources = exporter_instance.from_file(nb)
    return output, resources, exporter_instance


def export_sphinx_manual(nb, config=None, transformers=None, filters=None):
    """
    Export a notebook object to Sphinx Manual LaTeX
    
    Parameters
    ----------
    config : config
        User configuration instance.
    transformers : list[of transformer]
        Custom transformers to apply to the notebook prior to engaging
        the Jinja template engine.  Any transformers specified here 
        will override existing transformers if a naming conflict
        occurs.
    filters : list[of filter]
        Custom filters to make accessible to the Jinja templates.  Any
        filters specified here will override existing filters if a
        naming conflict occurs.
        
    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.
    """
    return export(nb, config, transformers, filters, SphinxManualExporter)


def export_sphinx_howto(nb, config=None, transformers=None, filters=None):
    """
    Export a notebook object to Sphinx HowTo LaTeX
    
    Parameters
    ----------
    config : config
        User configuration instance.
    transformers : list[of transformer]
        Custom transformers to apply to the notebook prior to engaging
        the Jinja template engine.  Any transformers specified here 
        will override existing transformers if a naming conflict
        occurs.
    filters : list[of filter]
        Custom filters to make accessible to the Jinja templates.  Any
        filters specified here will override existing filters if a
        naming conflict occurs.
        
    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.
    """
    return export(nb, config, transformers, filters, SphinxHowtoExporter)


def export_basic_html(nb, config=None, transformers=None, filters=None):
    """
    Export a notebook object to Basic HTML
    
    Parameters
    ----------
    config : config
        User configuration instance.
    transformers : list[of transformer]
        Custom transformers to apply to the notebook prior to engaging
        the Jinja template engine.  Any transformers specified here 
        will override existing transformers if a naming conflict
        occurs.
    filters : list[of filter]
        Custom filters to make accessible to the Jinja templates.  Any
        filters specified here will override existing filters if a
        naming conflict occurs.
        
    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.
    """
    return export(nb, config, transformers, filters, BasicHtmlExporter)


def export_full_html(nb, config=None, transformers=None, filters=None):
    """
    Export a notebook object to Full HTML
    
    Parameters
    ----------
    config : config
        User configuration instance.
    transformers : list[of transformer]
        Custom transformers to apply to the notebook prior to engaging
        the Jinja template engine.  Any transformers specified here 
        will override existing transformers if a naming conflict
        occurs.
    filters : list[of filter]
        Custom filters to make accessible to the Jinja templates.  Any
        filters specified here will override existing filters if a
        naming conflict occurs.
        
    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.
    """
    return export(nb, config, transformers, filters, FullHtmlExporter)


def export_latex(nb, config=None, transformers=None, filters=None):
    """
    Export a notebook object to LaTeX
    
    Parameters
    ----------
    config : config
        User configuration instance.
    transformers : list[of transformer]
        Custom transformers to apply to the notebook prior to engaging
        the Jinja template engine.  Any transformers specified here 
        will override existing transformers if a naming conflict
        occurs.
    filters : list[of filter]
        Custom filters to make accessible to the Jinja templates.  Any
        filters specified here will override existing filters if a
        naming conflict occurs.
        
    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.
    """
    return export(nb, config, transformers, filters, LatexExporter)


def export_markdown(nb, config=None, transformers=None, filters=None):
    """
    Export a notebook object to Markdown
    
    Parameters
    ----------
    config : config
        User configuration instance.
    transformers : list[of transformer]
        Custom transformers to apply to the notebook prior to engaging
        the Jinja template engine.  Any transformers specified here 
        will override existing transformers if a naming conflict
        occurs.
    filters : list[of filter]
        Custom filters to make accessible to the Jinja templates.  Any
        filters specified here will override existing filters if a
        naming conflict occurs.
        
    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.
    """
    return export(nb, config, transformers, filters, MarkdownExporter)


def export_python(nb, config=None, transformers=None, filters=None):
    """
    Export a notebook object to Python
    
    Parameters
    ----------
    config : config
        User configuration instance.
    transformers : list[of transformer]
        Custom transformers to apply to the notebook prior to engaging
        the Jinja template engine.  Any transformers specified here 
        will override existing transformers if a naming conflict
        occurs.
    filters : list[of filter]
        Custom filters to make accessible to the Jinja templates.  Any
        filters specified here will override existing filters if a
        naming conflict occurs.
        
    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.
    """
    return export(nb, config, transformers, filters, PythonExporter)


def export_python_armor(nb, config=None, transformers=None, filters=None):
    """
    Export a notebook object to Python (Armor)
    
    Parameters
    ----------
    config : config
        User configuration instance.
    transformers : list[of transformer]
        Custom transformers to apply to the notebook prior to engaging
        the Jinja template engine.  Any transformers specified here 
        will override existing transformers if a naming conflict
        occurs.
    filters : list[of filter]
        Custom filters to make accessible to the Jinja templates.  Any
        filters specified here will override existing filters if a
        naming conflict occurs.
        
    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.
    """
    return export(nb, config, transformers, filters, PythonArmorExporter)


def export_reveal(nb, config=None, transformers=None, filters=None):
    """
    Export a notebook object to Reveal
    
    Parameters
    ----------
    config : config
        User configuration instance.
    transformers : list[of transformer]
        Custom transformers to apply to the notebook prior to engaging
        the Jinja template engine.  Any transformers specified here 
        will override existing transformers if a naming conflict
        occurs.
    filters : list[of filter]
        Custom filters to make accessible to the Jinja templates.  Any
        filters specified here will override existing filters if a
        naming conflict occurs.
        
    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.
    """
    return export(nb, config, transformers, filters, RevealExporter)


def export_rst(nb, config=None, transformers=None, filters=None):
    """
    Export a notebook object to RST
    
    Parameters
    ----------
    config : config
        User configuration instance.
    transformers : list[of transformer]
        Custom transformers to apply to the notebook prior to engaging
        the Jinja template engine.  Any transformers specified here 
        will override existing transformers if a naming conflict
        occurs.
    filters : list[of filter]
        Custom filters to make accessible to the Jinja templates.  Any
        filters specified here will override existing filters if a
        naming conflict occurs.
        
    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.
    """
    return export(nb, config, transformers, filters, RstExporter)


def export_by_name(nb, template_name, config=None, transformers=None, filters=None):
    """
    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.
    
    Parameters
    ----------
    template_name : str
        Name of the template style to export to.
    config : config
        User configuration instance.
    transformers : list[of transformer]
        Custom transformers to apply to the notebook prior to engaging
        the Jinja template engine.  Any transformers specified here 
        will override existing transformers if a naming conflict
        occurs.
    filters : list[of filter]
        Custom filters to make accessible to the Jinja templates.  Any
        filters specified here will override existing filters if a
        naming conflict occurs.
        
    Returns
    ----------
    tuple- (output, resources, exporter_instance)
    None- if template not found
    
    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.
    """
    
    function_name = "export_" + template_name.lower()
    
    if function_name in globals():
        return globals()[function_name](nb, config, transformers, filters)
    else:
        return None