Merge pull request #3500 from ipython/nbconvert

Merge nbconvert into IPython

IPython/nbconvert/__init__.py

@@ -0,0 +1,5 b''
+"""Utilities for converting notebooks to and from different formats."""
+
+from .exporters import *
+import filters
+import transformers

IPython/nbconvert/exporters/__init__.py

@@ -0,0 +1,10 b''
+from .basichtml import BasicHtmlExporter
+from .export import *
+from .exporter import Exporter
+from .fullhtml import FullHtmlExporter
+from .latex import LatexExporter
+from .markdown import MarkdownExporter
+from .python import PythonExporter
+from .rst import RstExporter
+from .sphinx_howto import SphinxHowtoExporter
+from .sphinx_manual import SphinxManualExporter

IPython/nbconvert/exporters/basichtml.py

@@ -0,0 +1,55 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 ..transformers.csshtmlheader import CSSHtmlHeaderTransformer
+
+from .exporter import Exporter
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class BasicHtmlExporter(Exporter):
+    """
+    Exports a basic HTML document.  This exporter assists with the export of
+    HTML.  Inherit from it if you are writing your own HTML template and need
+    custom transformers/filters.  If you don't need custom transformers/
+    filters, just change the 'template_file' config option.  
+    """
+    
+    file_extension = Unicode(
+        'html', config=True, 
+        help="Extension of the file that should be written to disk"
+        )
+
+    template_file = Unicode(
+            'basichtml', config=True,
+            help="Name of the template file to use")
+
+
+    def _register_transformers(self):
+        """
+        Register all of the transformers needed for this exporter.
+        """
+        
+        #Register the transformers of the base class.
+        super(BasicHtmlExporter, self)._register_transformers()
+        
+        #Register CSSHtmlHeaderTransformer transformer
+        self.register_transformer(CSSHtmlHeaderTransformer)
+                    

IPython/nbconvert/exporters/export.py

@@ -0,0 +1,225 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 .exporter import Exporter
+from .basichtml import BasicHtmlExporter
+from .fullhtml import FullHtmlExporter
+from .latex import LatexExporter
+from .markdown import MarkdownExporter
+from .python import PythonExporter
+from .python_armor import PythonArmorExporter
+from .reveal import RevealExporter
+from .rst import RstExporter
+from .sphinx_howto import SphinxHowtoExporter
+from .sphinx_manual import SphinxManualExporter
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+def DocDecorator(f):    
+    
+    #Set docstring of function
+    f.__doc__ = f.__doc__ + """
+    nb : Notebook node
+    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."""
+            
+    @wraps(f)
+    def decorator(*args, **kwargs):
+        return f(*args, **kwargs)
+    
+    return decorator
+
+
+#-----------------------------------------------------------------------------
+# Functions
+#-----------------------------------------------------------------------------
+
+__all__ = [
+    'export',
+    'export_sphinx_manual',
+    'export_sphinx_howto',
+    'export_basic_html',
+    'export_full_html',
+    'export_latex',
+    'export_markdown',
+    'export_python',
+    'export_python_armor',
+    'export_reveal',
+    'export_rst',
+    'export_by_name'
+]
+
+@DocDecorator
+def export(exporter_type, nb, config=None, transformers=None, filters=None):
+    """
+    Export a notebook object using specific exporter class.
+    
+    exporter_type : Exporter class 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.}
+    """
+    
+    #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
+
+
+@DocDecorator
+def export_sphinx_manual(nb, config=None, transformers=None, filters=None):
+    """
+    Export a notebook object to Sphinx Manual LaTeX
+    """
+    return export(SphinxManualExporter, nb, config, transformers, filters)
+
+
+@DocDecorator
+def export_sphinx_howto(nb, config=None, transformers=None, filters=None):
+    """
+    Export a notebook object to Sphinx HowTo LaTeX
+    """
+    return export(SphinxHowtoExporter, nb, config, transformers, filters)
+
+
+@DocDecorator
+def export_basic_html(nb, config=None, transformers=None, filters=None):
+    """
+    Export a notebook object to Basic HTML
+    """
+    return export(BasicHtmlExporter, nb, config, transformers, filters)
+
+
+@DocDecorator
+def export_full_html(nb, config=None, transformers=None, filters=None):
+    """
+    Export a notebook object to Full HTML
+    """
+    return export(FullHtmlExporter, nb, config, transformers, filters)
+
+
+@DocDecorator
+def export_latex(nb, config=None, transformers=None, filters=None):
+    """
+    Export a notebook object to LaTeX
+    """
+    return export(LatexExporter, nb, config, transformers, filters)
+
+
+@DocDecorator
+def export_markdown(nb, config=None, transformers=None, filters=None):
+    """
+    Export a notebook object to Markdown
+    """
+    return export(MarkdownExporter, nb, config, transformers, filters)
+
+
+@DocDecorator
+def export_python(nb, config=None, transformers=None, filters=None):
+    """
+    Export a notebook object to Python
+    """
+    return export(PythonExporter, nb, config, transformers, filters)
+
+
+@DocDecorator
+def export_python_armor(nb, config=None, transformers=None, filters=None):
+    """
+    Export a notebook object to Python (Armor)
+    """
+    return export(PythonArmorExporter, nb, config, transformers, filters)
+
+
+@DocDecorator
+def export_reveal(nb, config=None, transformers=None, filters=None):
+    """
+    Export a notebook object to Reveal
+    """
+    return export(RevealExporter, nb, config, transformers, filters)
+
+
+@DocDecorator
+def export_rst(nb, config=None, transformers=None, filters=None):
+    """
+    Export a notebook object to RST
+    """
+    return export(RstExporter, nb, config, transformers, filters)
+
+
+@DocDecorator
+def export_by_name(template_name, nb, 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.
+    
+    template_name : str
+        Name of the template style to export to.
+    """
+    
+    function_name = "export_" + template_name.lower()
+    
+    if function_name in globals():
+        return globals()[function_name](nb, config, transformers, filters)
+    else:
+        return None
+

IPython/nbconvert/exporters/exporter.py

@@ -0,0 +1,341 b''
+"""This module defines Exporter, a highly configurable converter
+that uses Jinja2 to export notebook files into different formats.
+"""
+
+#-----------------------------------------------------------------------------
+# 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 inspect
+from copy import deepcopy
+
+# other libs/dependencies
+from jinja2 import Environment, FileSystemLoader
+from markdown import markdown
+
+# IPython imports
+from IPython.config.configurable import Configurable
+from IPython.config import Config
+from IPython.nbformat import current as nbformat
+from IPython.utils.traitlets import MetaHasTraits, Unicode
+from IPython.utils.text import indent
+
+from IPython.nbconvert import filters
+from IPython.nbconvert import transformers
+
+#-----------------------------------------------------------------------------
+# Globals and constants
+#-----------------------------------------------------------------------------
+
+#Jinja2 extensions to load.
+JINJA_EXTENSIONS = ['jinja2.ext.loopcontrols']
+
+default_filters = {
+        'indent': indent,
+        'markdown': markdown,
+        'ansi2html': filters.ansi2html,
+        'filter_data_type': filters.DataTypeFilter,
+        'get_lines': filters.get_lines,
+        'highlight': filters.highlight,
+        'highlight2html': filters.highlight,
+        'highlight2latex': filters.highlight2latex,
+        'markdown2latex': filters.markdown2latex,
+        'markdown2rst': filters.markdown2rst,
+        'pycomment': filters.python_comment,
+        'rm_ansi': filters.remove_ansi,
+        'rm_dollars': filters.strip_dollars,
+        'rm_fake': filters.rm_fake,
+        'ansi2latex': filters.ansi2latex,
+        'rm_math_space': filters.rm_math_space,
+        'wrap': filters.wrap
+}
+
+#-----------------------------------------------------------------------------
+# Class
+#-----------------------------------------------------------------------------
+
+class Exporter(Configurable):
+    """
+    Exports notebooks into other file formats.  Uses Jinja 2 templating engine
+    to output new formats.  Inherit from this class if you are creating a new
+    template type along with new filters/transformers.  If the filters/
+    transformers provided by default suffice, there is no need to inherit from
+    this class.  Instead, override the template_file and file_extension
+    traits via a config file.
+    
+    {filters}
+    """
+    
+    # finish the docstring
+    __doc__ = __doc__.format(filters = '- '+'\n    - '.join(default_filters.keys()))
+
+
+    template_file = Unicode(
+            '', config=True,
+            help="Name of the template file to use")
+
+    file_extension = Unicode(
+        'txt', config=True, 
+        help="Extension of the file that should be written to disk"
+        )
+
+    template_path = Unicode(
+        "/../templates/", config=True,
+        help="Path where the template files are located.")
+
+    template_skeleton_path = Unicode(
+        "/../templates/skeleton/", config=True,
+        help="Path where the template skeleton files are located.") 
+
+    #Jinja block definitions
+    jinja_comment_block_start = Unicode("", config=True)
+    jinja_comment_block_end = Unicode("", config=True)
+    jinja_variable_block_start = Unicode("", config=True)
+    jinja_variable_block_end = Unicode("", config=True)
+    jinja_logic_block_start = Unicode("", config=True)
+    jinja_logic_block_end = Unicode("", config=True)
+    
+    #Extension that the template files use.    
+    template_extension = Unicode(".tpl", config=True)
+
+    #Processors that process the input data prior to the export, set in the 
+    #constructor for this class.
+    transformers = None
+
+    
+    def __init__(self, transformers=None, filters=None, config=None, **kw):
+        """
+        Public constructor
+    
+        Parameters
+        ----------
+        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 : dict[of filter]
+            filters specified here will override existing filters if a naming
+            conflict occurs. Filters are availlable in jinja template through
+            the name of the corresponding key. Cf class docstring for
+            availlable default filters.
+        config : config
+            User configuration instance.
+        """
+        
+        #Call the base class constructor
+        c = self.default_config
+        if config:
+            c.merge(config)
+
+        super(Exporter, self).__init__(config=c, **kw)
+
+        #Standard environment
+        self._init_environment()
+
+        #Add transformers
+        self._register_transformers()
+
+        #Add filters to the Jinja2 environment
+        self._register_filters()
+
+        #Load user transformers.  Overwrite existing transformers if need be.
+        if transformers :
+            for transformer in transformers:
+                self.register_transformer(transformer)
+                
+        #Load user filters.  Overwrite existing filters if need be.
+        if not filters is None:
+            for key, user_filter in filters.iteritems():
+                if issubclass(user_filter, MetaHasTraits):
+                    self.environment.filters[key] = user_filter(config=config)
+                else:
+                    self.environment.filters[key] = user_filter
+
+    @property
+    def default_config(self):
+        return Config()
+
+    
+    
+    def from_notebook_node(self, nb, resources=None):
+        """
+        Convert a notebook from a notebook node instance.
+    
+        Parameters
+        ----------
+        nb : Notebook node
+        resources : a dict of additional resources that
+                can be accessed read/write by transformers
+                and filters.
+        """
+        if resources is None:
+            resources = {}
+        nb, resources = self._preprocess(nb, resources)
+        
+        #Load the template file.
+        self.template = self.environment.get_template(self.template_file+self.template_extension)
+        
+        return self.template.render(nb=nb, resources=resources), resources
+
+
+    def from_filename(self, filename):
+        """
+        Convert a notebook from a notebook file.
+    
+        Parameters
+        ----------
+        filename : str
+            Full filename of the notebook file to open and convert.
+        """
+        
+        with io.open(filename) as f:
+            return self.from_notebook_node(nbformat.read(f, 'json'))
+
+
+    def from_file(self, file_stream):
+        """
+        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'))
+
+
+    def register_transformer(self, transformer):
+        """
+        Register a transformer.
+        Transformers are classes that act upon the notebook before it is
+        passed into the Jinja templating engine.  Transformers are also
+        capable of passing additional information to the Jinja
+        templating engine.
+    
+        Parameters
+        ----------
+        transformer : transformer
+        """
+        if self.transformers is None:
+            self.transformers = []
+        
+        if inspect.isfunction(transformer):
+            self.transformers.append(transformer)
+            return transformer
+        elif isinstance(transformer, MetaHasTraits):
+            transformer_instance = transformer(config=self.config)
+            self.transformers.append(transformer_instance)
+            return transformer_instance
+        else:
+            transformer_instance = transformer()
+            self.transformers.append(transformer_instance)
+            return transformer_instance
+
+
+    def register_filter(self, name, filter):
+        """
+        Register a filter.
+        A filter is a function that accepts and acts on one string.  
+        The filters are accesible within the Jinja templating engine.
+    
+        Parameters
+        ----------
+        name : str
+            name to give the filter in the Jinja engine
+        filter : filter
+        """
+        if inspect.isfunction(filter):
+            self.environment.filters[name] = filter
+        elif isinstance(filter, MetaHasTraits):
+            self.environment.filters[name] = filter(config=self.config)
+        else:
+            self.environment.filters[name] = filter()
+        return self.environment.filters[name]
+
+    
+    def _register_transformers(self):
+        """
+        Register all of the transformers needed for this exporter.
+        """
+         
+        self.register_transformer(transformers.coalesce_streams)
+        
+        #Remember the figure extraction transformer so it can be enabled and
+        #disabled easily later.
+        self.extract_figure_transformer = self.register_transformer(transformers.ExtractFigureTransformer)
+        
+        
+    def _register_filters(self):
+        """
+        Register all of the filters required for the exporter.
+        """
+        for k, v in default_filters.iteritems():
+            self.register_filter(k, v)
+        
+        
+    def _init_environment(self):
+        """
+        Create the Jinja templating environment.
+        """
+        
+        self.environment = Environment(
+            loader=FileSystemLoader([
+                os.path.dirname(os.path.realpath(__file__)) + self.template_path,
+                os.path.dirname(os.path.realpath(__file__)) + self.template_skeleton_path,
+                ]),
+            extensions=JINJA_EXTENSIONS
+            )
+        
+        #Set special Jinja2 syntax that will not conflict with latex.
+        if self.jinja_logic_block_start:
+            self.environment.block_start_string = self.jinja_logic_block_start
+        if self.jinja_logic_block_end:
+            self.environment.block_end_string = self.jinja_logic_block_end
+        if self.jinja_variable_block_start:
+            self.environment.variable_start_string = self.jinja_variable_block_start
+        if self.jinja_variable_block_end:
+            self.environment.variable_end_string = self.jinja_variable_block_end
+        if self.jinja_comment_block_start:
+            self.environment.comment_start_string = self.jinja_comment_block_start
+        if self.jinja_comment_block_end:
+            self.environment.comment_end_string = self.jinja_comment_block_end
+
+
+    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 transformers
+            and filters.
+        """
+        
+        # Do a deepcopy first, 
+        # we are never safe enough with what the transformers could do.
+        nbc =  deepcopy(nb)
+        resc = deepcopy(resources)
+        #Run each transformer on the notebook.  Carry the output along
+        #to each transformer
+        for transformer in self.transformers:
+            nb, resources = transformer(nbc, resc)
+        return nb, resources
+

IPython/nbconvert/exporters/fullhtml.py

@@ -0,0 +1,39 b''
+"""
+Exporter for exporting full HTML documents.
+"""
+
+#-----------------------------------------------------------------------------
+# 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 .basichtml import BasicHtmlExporter
+from IPython.config import Config
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class FullHtmlExporter(BasicHtmlExporter):
+    """
+    Exports a full HTML document.
+    """
+
+    template_file = Unicode(
+            'fullhtml', config=True,
+            help="Name of the template file to use")
+
+    @property
+    def default_config(self):
+        c = Config({'CSSHtmlHeaderTransformer':{'enabled':True}})
+        c.merge(super(FullHtmlExporter,self).default_config)
+        return c

IPython/nbconvert/exporters/latex.py

@@ -0,0 +1,105 b''
+"""
+Exporter that allows Latex Jinja templates to work.  Contains logic to
+appropriately prepare IPYNB files for export to LaTeX.  Including but 
+not limited to escaping LaTeX, fixing math region tags, using special
+tags to circumvent Jinja/Latex syntax conflicts.
+"""
+#-----------------------------------------------------------------------------
+# 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
+#-----------------------------------------------------------------------------
+
+# IPython imports
+from IPython.utils.traitlets import Unicode
+from IPython.config import Config
+
+from IPython.nbconvert import filters, transformers
+from .exporter import Exporter
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+class LatexExporter(Exporter):
+    """
+    Exports to a Latex template.  Inherit from this class if your template is
+    LaTeX based and you need custom tranformers/filters.  Inherit from it if 
+    you are writing your own HTML template and need custom tranformers/filters.  
+    If you don't need custom tranformers/filters, just change the 
+    'template_file' config option.  Place your template in the special "/latex" 
+    subfolder of the "../templates" folder.
+    """
+    
+    file_extension = Unicode(
+        'tex', config=True, 
+        help="Extension of the file that should be written to disk")
+
+    template_file = Unicode(
+        'base', config=True,
+        help="Name of the template file to use")
+
+    #Latex constants
+    template_path = Unicode(
+        "/../templates/latex/", config=True,
+        help="Path where the template files are located.")
+
+    template_skeleton_path = Unicode(
+        "/../templates/latex/skeleton/", config=True,
+        help="Path where the template skeleton files are located.") 
+
+    #Special Jinja2 syntax that will not conflict when exporting latex.
+    jinja_comment_block_start = Unicode("((=", config=True)
+    jinja_comment_block_end = Unicode("=))", config=True)
+    jinja_variable_block_start = Unicode("(((", config=True)
+    jinja_variable_block_end = Unicode(")))", config=True)
+    jinja_logic_block_start = Unicode("((*", config=True)
+    jinja_logic_block_end = Unicode("*))", config=True)
+    
+    #Extension that the template files use.    
+    template_extension = Unicode(".tplx", config=True)
+
+    def _register_filters(self):
+        """
+        Register all of the filters required for the exporter.
+        """
+        
+        #Register the filters of the base class.
+        super(LatexExporter, self)._register_filters()
+
+        #Add latex filters to the Jinja2 environment
+        self.register_filter('escape_tex', filters.escape_latex) 
+        self.register_filter('highlight', filters.highlight2latex) 
+    
+    
+    def _register_transformers(self):
+        """
+        Register all of the transformers needed for this exporter.
+        """
+        
+        #Register the transformers of the base class.
+        super(LatexExporter, self)._register_transformers()
+        
+        #Register latex transformer
+        self.register_transformer(transformers.LatexTransformer)
+
+    @property
+    def default_config(self):
+        c = Config({
+            'GlobalConfigurable': {
+                'display_data_priority' : ['latex', 'svg', 'png', 'jpg', 'jpeg' , 'text']
+                },
+             'ExtractFigureTransformer': {
+                    'enabled':True,
+                    'extra_ext_map':{'svg':'pdf'},
+                 }
+         })
+        c.merge(super(LatexExporter,self).default_config)
+        return c
+

IPython/nbconvert/exporters/markdown.py

@@ -0,0 +1,35 b''
+"""
+Exporter that will export your ipynb to Markdown.
+"""
+#-----------------------------------------------------------------------------
+# 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 .exporter import Exporter
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class MarkdownExporter(Exporter):
+    """
+    Exports to a markdown document (.md)
+    """
+    
+    file_extension = Unicode(
+        'md', config=True, 
+        help="Extension of the file that should be written to disk")
+
+    template_file = Unicode(
+            'markdown', config=True,
+            help="Name of the template file to use")

IPython/nbconvert/exporters/python.py

@@ -0,0 +1,35 b''
+"""
+Python exporter which exports Notebook code into a PY file.
+"""
+#-----------------------------------------------------------------------------
+# 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 .exporter import Exporter
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class PythonExporter(Exporter):
+    """
+    Exports a Python code file.
+    """
+    
+    file_extension = Unicode(
+        'py', config=True, 
+        help="Extension of the file that should be written to disk")
+
+    template_file = Unicode(
+            'python', config=True,
+            help="Name of the template file to use")

IPython/nbconvert/exporters/python_armor.py

@@ -0,0 +1,32 b''
+"""
+Exporter that exports a Python-Armor code file (.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.utils.traitlets import Unicode
+
+from .python import PythonExporter
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class PythonArmorExporter(PythonExporter):
+    """
+    Exports a Python-Armor code file (.py)
+    """
+
+    template_file = Unicode(
+            'python_armor', config=True,
+            help="Name of the template file to use")

IPython/nbconvert/exporters/reveal.py

@@ -0,0 +1,54 b''
+"""
+Reveal slide show exporter.
+"""
+#-----------------------------------------------------------------------------
+# 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.config import Config
+
+from .basichtml import BasicHtmlExporter
+from IPython.nbconvert import transformers
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class RevealExporter(BasicHtmlExporter):
+    """
+    Exports a Reveal slide show (.HTML) which may be rendered in a web browser.
+    """
+    
+    file_extension = Unicode(
+        'reveal.html', config=True, 
+        help="Extension of the file that should be written to disk")
+
+    template_file = Unicode(
+            'reveal', config=True,
+            help="Name of the template file to use")
+    
+    def _register_transformers(self):
+        """
+        Register all of the transformers needed for this exporter.
+        """
+        
+        #Register the transformers of the base class.
+        super(RevealExporter, self)._register_transformers()
+        
+        #Register reveal help transformer
+        self.register_transformer(transformers.RevealHelpTransformer)
+
+    @property
+    def default_config(self):
+        c = Config({'CSSHtmlHeaderTransformer':{'enabled':True}})
+        c.merge(super(RevealExporter,self).default_config)
+        return c

IPython/nbconvert/exporters/rst.py

@@ -0,0 +1,42 b''
+"""
+Exporter for exporting notebooks to restructured text.
+"""
+#-----------------------------------------------------------------------------
+# 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.config import Config
+
+from .exporter import Exporter
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class RstExporter(Exporter):
+    """
+    Exports restructured text documents.
+    """
+    
+    file_extension = Unicode(
+        'rst', config=True, 
+        help="Extension of the file that should be written to disk")
+
+    template_file = Unicode(
+            'rst', config=True,
+            help="Name of the template file to use")
+
+    @property
+    def default_config(self):
+        c = Config({'ExtractFigureTransformer':{'enabled':True}})
+        c.merge(super(RstExporter,self).default_config)
+        return c

IPython/nbconvert/exporters/sphinx_howto.py

@@ -0,0 +1,54 b''
+"""
+Exporter for exporting notebooks to Sphinx 'HowTo' style latex.  Latex 
+formatted for use with PDFLatex.
+"""
+#-----------------------------------------------------------------------------
+# 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.config import Config
+
+# local import
+from .latex import LatexExporter
+
+from IPython.nbconvert import transformers
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class SphinxHowtoExporter(LatexExporter):
+    """
+    Exports Sphinx "HowTo" LaTeX documents.  The Sphinx "HowTo" exporter 
+    produces short document format latex for use with PDFLatex.
+    """
+    
+    template_file = Unicode(
+            'sphinx_howto', config=True,
+            help="Name of the template file to use")
+
+    def _register_transformers(self):
+        
+        #Register the transformers of the base class.
+        super(SphinxHowtoExporter, self)._register_transformers()
+        
+        #Register sphinx latex transformer
+        self.register_transformer(transformers.SphinxTransformer) 
+
+    @property
+    def default_config(self):
+        c = Config({
+        'SphinxTransformer': {'enabled':True}
+        })
+        c.merge(super(SphinxHowtoExporter,self).default_config)
+        return c
+                    

IPython/nbconvert/exporters/sphinx_manual.py

@@ -0,0 +1,34 b''
+"""
+Exporter for exporting notebooks to Sphinx 'Manual' style latex.  Latex 
+formatted for use with PDFLatex.
+"""
+#-----------------------------------------------------------------------------
+# 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 .sphinx_howto import SphinxHowtoExporter
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class SphinxManualExporter(SphinxHowtoExporter):
+    """
+    Exports Sphinx "Manual" LaTeX documents.  The Sphinx "Manual" exporter 
+    produces book like latex output for use with PDFLatex. 
+    """
+    
+    template_file = Unicode(
+            'sphinx_manual', config=True,
+            help="Name of the template file to use")
+    
  No newline at end of file

IPython/nbconvert/filters/__init__.py

@@ -0,0 +1,6 b''
+from .ansi import *
+from .datatypefilter import *
+from .highlight import *
+from .latex import *
+from .markdown import *
+from .strings import *
  No newline at end of file

IPython/nbconvert/filters/ansi.py

@@ -0,0 +1,145 b''
+"""Filters for processing ANSI colors within Jinja templates.
+"""
+#-----------------------------------------------------------------------------
+# 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 re
+from IPython.utils import coloransi
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+__all__ = [
+    'remove_ansi',
+    'ansi2html',
+    'single_ansi2latex',
+    'ansi2latex'
+]
+
+def remove_ansi(source):
+    """
+    Remove ansi from text
+    
+    Parameters
+    ----------
+    source : str
+        Source to remove the ansi from
+    """
+    
+    return re.sub(r'\033\[(0|\d;\d\d)m', '', source)
+
+
+def ansi2html(text):
+    """
+    Conver ansi colors to html colors.
+    
+    Parameters
+    ----------
+    text : str
+        Text containing ansi colors to convert to html
+    """
+    
+    ansi_colormap = {
+        '30': 'ansiblack',
+        '31': 'ansired',
+        '32': 'ansigreen',
+        '33': 'ansiyellow',
+        '34': 'ansiblue',
+        '35': 'ansipurple',
+        '36': 'ansicyan',
+        '37': 'ansigrey',
+        '01': 'ansibold',
+    }
+
+    # do ampersand first
+    text = text.replace('&', '&')
+    html_escapes = {
+        '<': '&lt;',
+        '>': '&gt;',
+        "'": '&apos;',
+        '"': '&quot;',
+        '`': '&#96;',
+    }
+    
+    for c, escape in html_escapes.iteritems():
+        text = text.replace(c, escape)
+
+    ansi_re = re.compile('\x1b' + r'\[([\dA-Fa-f;]*?)m')
+    m = ansi_re.search(text)
+    opened = False
+    cmds = []
+    opener = ''
+    closer = ''
+    while m:
+        cmds = m.groups()[0].split(';')
+        closer = '</span>' if opened else ''
+        
+        # True if there is there more than one element in cmds, *or*
+        # if there is only one but it is not equal to a string of zeroes.
+        opened = len(cmds) > 1 or cmds[0] != '0' * len(cmds[0])
+        classes = []
+        for cmd in cmds:
+            if cmd in ansi_colormap:
+                classes.append(ansi_colormap.get(cmd))
+
+        if classes:
+            opener = '<span class="%s">' % (' '.join(classes))
+        else:
+            opener = ''
+        text = re.sub(ansi_re, closer + opener, text, 1)
+
+        m = ansi_re.search(text)
+
+    if opened:
+        text += '</span>'
+    return text
+
+
+def single_ansi2latex(code):
+    """Converts single ansi markup to latex format
+
+    Return latex code and number of open brackets.
+    """
+    for color in coloransi.color_templates:
+        colcode = getattr(coloransi.TermColors,color[0])
+        # regular fonts
+        if code == colcode:
+            return '\\'+color[0].lower()+'{', 1
+        # bold fonts
+        if code == colcode[:3]+str(1)+colcode[3:]:
+            return '\\textbf{\\textcolor{'+color[0].lower()+'}{', 2
+    return '', 0
+
+def ansi2latex(text):
+    """Converts ansi formated text to latex version
+
+    based on https://bitbucket.org/birkenfeld/sphinx-contrib/ansi.py
+    """
+    color_pattern = re.compile('\x1b\\[([^m]+)m')
+    last_end = 0
+    openbrack = 0
+    outstring = ''
+    for match in color_pattern.finditer(text):
+        head = text[last_end:match.start()]
+        outstring += head
+        if openbrack:
+            outstring += '}'*openbrack
+            openbrack = 0
+        if match.group() <> coloransi.TermColors.Normal and not openbrack:
+            texform, openbrack = single_ansi2latex(match.group())
+            outstring += texform
+        last_end = match.end()
+    if openbrack: 
+        outstring += '}'*openbrack
+    outstring += text[last_end:]
+    return outstring.strip()

IPython/nbconvert/filters/datatypefilter.py

@@ -0,0 +1,33 b''
+"""Filter used to select the first preferred output format available.
+
+The filter contained in the file allows the converter templates to select
+the output format that is most valuable to the active export format.  The
+value of the different formats is set via 
+GlobalConfigurable.display_data_priority
+"""
+#-----------------------------------------------------------------------------
+# 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.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+from ..utils.config import GlobalConfigurable
+
+__all__ = ['DataTypeFilter']
+
+class DataTypeFilter(GlobalConfigurable):
+    """ Returns the preferred display format """
+
+    def __call__(self, output):
+        """ Return the first available format in the priority """
+
+        for fmt in self.display_data_priority:
+            if fmt in output:
+                return [fmt]
+        return []

IPython/nbconvert/filters/highlight.py

@@ -0,0 +1,88 b''
+"""
+Module containing filter functions that allow code to be highlighted
+from within Jinja templates.
+"""
+#-----------------------------------------------------------------------------
+# 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  pygments import highlight as pygements_highlight
+from pygments.lexers import get_lexer_by_name
+from pygments.formatters import HtmlFormatter
+from pygments.formatters import LatexFormatter
+
+# Our own imports
+from IPython.nbconvert.utils.lexers import IPythonLexer
+
+#-----------------------------------------------------------------------------
+# Globals and constants
+#-----------------------------------------------------------------------------
+
+MULTILINE_OUTPUTS = ['text', 'html', 'svg', 'latex', 'javascript', 'json']
+
+#-----------------------------------------------------------------------------
+# Utility functions
+#-----------------------------------------------------------------------------
+
+__all__ = [
+    'highlight',
+    'highlight2latex'
+]
+
+
+def highlight(source, language='ipython'):
+    """
+    Return a syntax-highlighted version of the input source as html output.
+    
+    Parameters
+    ----------
+    source : str
+        Source code to highlight the syntax of.
+    language : str
+        Language to highlight the syntax of.
+    """
+    
+    return _pygment_highlight(source, HtmlFormatter(), language)
+
+
+def highlight2latex(source, language='ipython'):
+    """
+    Return a syntax-highlighted version of the input source as latex output.
+    
+    Parameters
+    ----------
+    source : str
+        Source code to highlight the syntax of.
+    language : str
+        Language to highlight the syntax of.
+    """
+    return _pygment_highlight(source, LatexFormatter(), language)
+
+
+def _pygment_highlight(source, output_formatter, language='ipython'):
+    """
+    Return a syntax-highlighted version of the input source
+    
+    Parameters
+    ----------
+    source : str
+        Source code to highlight the syntax of.
+    output_formatter : Pygments formatter
+    language : str
+        Language to highlight the syntax of.
+    """
+    
+    if language == 'ipython':
+        lexer = IPythonLexer()
+    else:
+        lexer = get_lexer_by_name(language, stripall=True)
+
+    return pygements_highlight(source, lexer, output_formatter) 

IPython/nbconvert/filters/latex.py

@@ -0,0 +1,115 b''
+"""Latex filters.
+
+Module of useful filters for processing Latex within Jinja latex templates.
+"""
+#-----------------------------------------------------------------------------
+# 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 re
+
+#-----------------------------------------------------------------------------
+# Globals and constants
+#-----------------------------------------------------------------------------
+
+#Latex substitutions for escaping latex.
+LATEX_SUBS = (
+    (re.compile('\033\[[0-9;]+m'),''),  # handle console escapes
+    (re.compile(r'\\'), r'\\textbackslash'),
+    (re.compile(r'([{}_#%&$])'), r'\\\1'),
+    (re.compile(r'~'), r'\~{}'),
+    (re.compile(r'\^'), r'\^{}'),
+    (re.compile(r'"'), r"''"),
+    (re.compile(r'\.\.\.+'), r'\\ldots'),
+)
+
+#-----------------------------------------------------------------------------
+# Functions
+#-----------------------------------------------------------------------------
+
+__all__ = [
+    'escape_latex',
+    'rm_math_space'
+]
+
+
+def escape_latex(text):
+    """
+    Escape characters that may conflict with latex.
+    
+    Parameters
+    ----------
+    text : str
+        Text containing characters that may conflict with Latex
+    """
+    return_text = text
+    for pattern, replacement in LATEX_SUBS:
+        return_text = pattern.sub(replacement, return_text)
+    return return_text
+    
+    
+def rm_math_space(text):
+    """
+    Remove the space between latex math commands and enclosing $ symbols.
+    This filter is important because latex isn't as flexible as the notebook
+    front end when it comes to flagging math using ampersand symbols.
+    
+    Parameters
+    ----------
+    text : str
+        Text to filter.
+    """
+
+    # First, scan through the markdown looking for $.  If
+    # a $ symbol is found, without a preceding \, assume
+    # it is the start of a math block.  UNLESS that $ is
+    # not followed by another within two math_lines.
+    math_regions = []
+    math_lines = 0
+    within_math = False
+    math_start_index = 0
+    ptext = ''
+    last_character = ""
+    skip = False
+    for index, char in enumerate(text):
+
+        #Make sure the character isn't preceeded by a backslash
+        if (char == "$" and last_character != "\\"):
+
+            # Close the math region if this is an ending $
+            if within_math:
+                within_math = False
+                skip = True
+                ptext = ptext+'$'+text[math_start_index+1:index].strip()+'$'
+                math_regions.append([math_start_index, index+1])
+            else:
+
+                # Start a new math region
+                within_math = True
+                math_start_index = index
+                math_lines = 0
+
+        # If we are in a math region, count the number of lines parsed.
+        # Cancel the math region if we find two line breaks!
+        elif char == "\n":
+            if within_math:
+                math_lines += 1
+                if math_lines > 1:
+                    within_math = False
+                    ptext = ptext+text[math_start_index:index]
+
+        # Remember the last character so we can easily watch
+        # for backslashes
+        last_character = char
+        if not within_math and not skip:
+            ptext = ptext+char
+        if skip:
+            skip = False
+    return ptext

IPython/nbconvert/filters/markdown.py

@@ -0,0 +1,85 b''
+"""Markdown filters
+This file contains a collection of utility filters for dealing with 
+markdown within Jinja templates.
+"""
+#-----------------------------------------------------------------------------
+# 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
+
+# Stdlib imports
+import sys
+import subprocess
+
+#-----------------------------------------------------------------------------
+# Functions
+#-----------------------------------------------------------------------------
+
+__all__ = [
+    'markdown2latex',
+    'markdown2rst'
+]
+
+
+def markdown2latex(source):
+    """Convert a markdown string to LaTeX via pandoc.
+
+    This function will raise an error if pandoc is not installed.
+    Any error messages generated by pandoc are printed to stderr.
+
+    Parameters
+    ----------
+    source : string
+      Input string, assumed to be valid markdown.
+
+    Returns
+    -------
+    out : string
+      Output as returned by pandoc.
+    """
+    p = subprocess.Popen('pandoc -f markdown -t latex'.split(),
+                         stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+    
+    out, err = p.communicate(source.encode('utf-8'))
+    
+    if err:
+        print(err, file=sys.stderr)
+    #print('*'*20+'\n', out, '\n'+'*'*20)  # dbg
+    
+    return unicode(out, 'utf-8')[:-1]
+
+
+def markdown2rst(source):
+    """Convert a markdown string to LaTeX via pandoc.
+
+    This function will raise an error if pandoc is not installed.
+    Any error messages generated by pandoc are printed to stderr.
+
+    Parameters
+    ----------
+    source : string
+      Input string, assumed to be valid markdown.
+
+    Returns
+    -------
+    out : string
+      Output as returned by pandoc.
+    """
+    p = subprocess.Popen('pandoc -f markdown -t rst'.split(),
+                         stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+    
+    out, err = p.communicate(source.encode('utf-8'))
+    
+    if err:
+        print(err, file=sys.stderr)
+    #print('*'*20+'\n', out, '\n'+'*'*20)  # dbg
+    
+    return unicode(out, 'utf-8')

IPython/nbconvert/filters/strings.py

@@ -0,0 +1,113 b''
+"""String filters.
+
+Contains a collection of useful string manipulation filters for use in Jinja
+templates.
+"""
+#-----------------------------------------------------------------------------
+# 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
+#-----------------------------------------------------------------------------
+
+# Our own imports
+import textwrap
+
+#-----------------------------------------------------------------------------
+# Functions
+#-----------------------------------------------------------------------------
+
+__all__ = [
+    'wrap',
+    'strip_dollars',
+    'rm_fake',
+    'python_comment',
+    'get_lines'
+]
+
+
+def wrap(text, width=100):
+    """ 
+    Intelligently wrap text.
+    Wrap text without breaking words if possible.
+    
+    Parameters
+    ----------
+    text : str
+        Text to wrap.
+    width : int, optional
+        Number of characters to wrap to, default 100.
+    """
+
+    split_text = text.split('\n')
+    wrp = map(lambda x:textwrap.wrap(x,width), split_text)
+    wrpd = map('\n'.join, wrp)
+    return '\n'.join(wrpd)
+
+
+def strip_dollars(text):
+    """
+    Remove all dollar symbols from text
+    
+    Parameters
+    ----------
+    text : str
+        Text to remove dollars from
+    """
+
+    return text.strip('$')
+
+
+def rm_fake(text):
+    """
+    Remove all occurrences of '/files/' from text
+    
+    Parameters
+    ----------
+    text : str
+        Text to remove '/files/' from
+    """
+    return text.replace('/files/', '')
+
+
+def python_comment(text):
+    """
+    Build a Python comment line from input text.
+    
+    Parameters
+    ----------
+    text : str
+        Text to comment out.
+    """
+    
+    #Replace line breaks with line breaks and comment symbols.
+    #Also add a comment symbol at the beginning to comment out
+    #the first line.
+    return '# '+'\n# '.join(text.split('\n')) 
+
+
+def get_lines(text, start=None,end=None):
+    """
+    Split the input text into separate lines and then return the 
+    lines that the caller is interested in.
+    
+    Parameters
+    ----------
+    text : str
+        Text to parse lines from.
+    start : int, optional
+        First line to grab from.
+    end : int, optional
+        Last line to grab from.
+    """
+    
+    # Split the input into lines.
+    lines = text.split("\n")
+    
+    # Return the right lines.
+    return "\n".join(lines[start:end]) #re-join

IPython/nbconvert/nbconvertapp.py

@@ -0,0 +1,212 b''
+#!/usr/bin/env python
+"""NBConvert is a utility for conversion of IPYNB files.
+
+Commandline interface for the NBConvert conversion utility.  Read the
+readme.rst for usage information
+"""
+#-----------------------------------------------------------------------------
+#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 io
+import os
+
+#From IPython
+from IPython.config.application import Application
+from IPython.utils.traitlets import Bool
+
+from .exporters.export import export_by_name
+from .exporters.exporter import Exporter
+from .transformers import extractfigure
+from .utils.config import GlobalConfigurable
+
+#-----------------------------------------------------------------------------
+#Globals and constants
+#-----------------------------------------------------------------------------
+
+#'Keys in resources' user prompt.
+KEYS_PROMPT_HEAD = "====================== Keys in Resources =================================="
+KEYS_PROMPT_BODY = """
+===========================================================================
+You are responsible for writting these files into the appropriate 
+directorie(s) if need be.  If you do not want to see this message, enable
+the 'write' (boolean) flag of the converter.
+===========================================================================
+"""
+
+#-----------------------------------------------------------------------------
+#Classes and functions
+#-----------------------------------------------------------------------------
+
+class NbConvertApp(Application):
+    """Application used to convert to and from notebook file type (*.ipynb)"""
+
+    stdout = Bool(
+        False, config=True,
+        help="""Whether to print the converted IPYNB file to stdout
+        use full do diff files without actually writing a new file"""
+        )
+
+    write = Bool(
+        True, config=True,
+        help="""Should the converted notebook file be written to disk
+        along with potential extracted resources."""
+        )
+
+    aliases = {
+             'stdout':'NbConvertApp.stdout',
+             'write':'NbConvertApp.write',
+             }
+
+    flags = {}
+
+    flags['stdout'] = (
+        {'NbConvertApp' : {'stdout' : True}},
+    """Print converted file to stdout, equivalent to --stdout=True
+    """
+    )
+
+    flags['no-write'] = (
+        {'NbConvertApp' : {'write' : True}},
+    """Do not write to disk, equivalent to --write=False
+    """
+    )
+
+
+    def __init__(self, **kwargs):
+        """Public constructor"""
+
+        #Call base class
+        super(NbConvertApp, self).__init__(**kwargs)
+
+        #Register class here to have help with help all
+        self.classes.insert(0, Exporter)
+        self.classes.insert(0, GlobalConfigurable)
+
+
+    def start(self, argv=None):
+        """Entrypoint of NbConvert application.
+        
+        Parameters
+        ----------
+        argv : list
+            Commandline arguments
+        """
+        
+        #Parse the commandline options.
+        self.parse_command_line(argv)
+
+        #Call base
+        super(NbConvertApp, self).start()
+
+        #The last arguments in list will be used by nbconvert
+        if len(self.extra_args) is not 3:
+            print( "Wrong number of arguments, use --help flag for usage", file=sys.stderr)
+            sys.exit(-1)
+        export_type = (self.extra_args)[1]
+        ipynb_file = (self.extra_args)[2]
+        
+        #Export
+        return_value = export_by_name(export_type, ipynb_file)
+        if return_value is None:
+            print("Error: '%s' template not found." % export_type)
+            return
+        else:
+            (output, resources, exporter) = return_value 
+        
+        #TODO: Allow user to set output directory and file. 
+        destination_filename = None
+        destination_directory = None
+        if self.write:
+                
+            #Get the file name without the '.ipynb' (6 chars) extension and then
+            #remove any addition periods and spaces. The resulting name will
+            #be used to create the directory that the files will be exported
+            #into.
+            out_root = ipynb_file[:-6].replace('.', '_').replace(' ', '_')
+            destination_filename = os.path.join(out_root+'.'+exporter.file_extension)
+            
+            destination_directory = out_root+'_files'
+            if not os.path.exists(destination_directory):
+                os.mkdir(destination_directory)
+                
+        #Write the results
+        if self.stdout or not (destination_filename is None and destination_directory is None):
+            self._write_results(output, resources, destination_filename, destination_directory)
+
+
+    def _write_results(self, output, resources, destination_filename=None, destination_directory=None):
+        """Output the conversion results to the console and/or filesystem
+        
+        Parameters
+        ----------
+        output : str
+            Output of conversion
+        resources : dictionary
+            Additional input/output used by the transformers.  For
+            example, the ExtractFigure transformer outputs the
+            figures it extracts into this dictionary.  This method
+            relies on the figures being in this dictionary when
+            attempting to write the figures to the file system.
+        destination_filename : str, Optional
+            Filename to write output into.  If None, output is not 
+            written to a file.
+        destination_directory : str, Optional 
+            Directory to write notebook data (i.e. figures) to.  If
+            None, figures are not written to the file system.
+        """
+        
+        if self.stdout:
+            print(output.encode('utf-8'))
+
+        #Write file output from conversion.
+        if not destination_filename is None:
+            with io.open(destination_filename, 'w') as f:
+                f.write(output)
+
+        #Get the key names used by the extract figure transformer
+        figures_key = extractfigure.FIGURES_KEY
+        binary_key = extractfigure.BINARY_KEY
+        text_key = extractfigure.TEXT_KEY
+        
+        #Output any associate figures into the same "root" directory.
+        binkeys = resources.get(figures_key, {}).get(binary_key,{}).keys()
+        textkeys = resources.get(figures_key, {}).get(text_key,{}).keys()
+        if binkeys or textkeys :
+            if not destination_directory is None:
+                for key in binkeys:
+                    with io.open(os.path.join(destination_directory, key), 'wb') as f:
+                        f.write(resources[figures_key][binary_key][key])
+                for key in textkeys:
+                    with io.open(os.path.join(destination_directory, key), 'w') as f:
+                        f.write(resources[figures_key][text_key][key])
+
+            #Figures that weren't exported which will need to be created by the
+            #user.  Tell the user what figures these are.
+            if self.stdout:
+                print(KEYS_PROMPT_HEAD, file=sys.stderr)
+                print(resources[figures_key].keys(), file=sys.stderr)
+                print(KEYS_PROMPT_BODY , file=sys.stderr)
+
+#-----------------------------------------------------------------------------
+# Main entry point
+#-----------------------------------------------------------------------------
+
+def launch_new_instance():
+    """Application entry point"""
+
+    app = NbConvertApp.instance()
+    app.description = __doc__
+    app.start(argv=sys.argv)
+

IPython/nbconvert/templates/align_reveal_cells.tpl

@@ -0,0 +1,17 b''
+{%- extends 'reveal_cells.tpl' -%}
+
+
+
+{%- block any_cell scoped -%}
+{%- if cell.metadata.align_type in ['Left'] -%}  
+    {{ super() }}
+{%- elif cell.metadata.align_type in ['center'] -%}
+    <div style="text-align:center">
+    {{ super() }}
+    </div>
+{%- elif cell.metadata.align_type in ['right'] -%}
+    <div style="text-align:right">
+    {{ super() }}
+    </div>
+{%- endif -%}   
+{%- endblock any_cell -%}

IPython/nbconvert/templates/basichtml.tpl

@@ -0,0 +1,143 b''
+{%- extends 'display_priority.tpl' -%}
+
+
+
+{% block codecell %}
+<div class="cell border-box-sizing code_cell vbox">
+{{ super() }}</div>
+{%- endblock codecell %}
+
+{% block input_group -%}
+<div class="input hbox">
+{{super()}}
+</div>
+{% endblock input_group %}
+
+{% block output_group %}
+<div class="vbox output_wrapper">
+<div class="output vbox">
+{{ super() }}
+</div>
+</div>
+{% endblock output_group %}
+
+{% block in_prompt -%}
+<div class="prompt input_prompt">In&nbsp;[{{cell.prompt_number}}]:</div>
+{%- endblock in_prompt %}
+
+{# 
+  output_prompt doesn't do anything in HTML,
+  because there is a prompt div in each output area (see output block)
+#}
+{% block output_prompt %}
+{% endblock output_prompt %}
+
+{% block input %}
+<div class="input_area box-flex1">
+{{cell.input | highlight }}
+</div>
+{%- endblock input %}
+
+{% block output %}
+<div class="hbox output_area">
+{%- if output.output_type == 'pyout' -%}
+<div class="prompt output_prompt">
+Out[{{cell.prompt_number}}]:
+{%- else -%}
+<div class="prompt">
+{%- endif -%}
+</div>
+{{ super() }}
+</div>
+{% endblock output %}
+
+{% block markdowncell scoped %}
+<div class="text_cell_render border-box-sizing rendered_html">
+{{ cell.source | markdown| rm_fake}}
+</div>
+{%- endblock markdowncell %}
+
+{% block headingcell scoped %}
+<div class="text_cell_render border-box-sizing rendered_html">
+<h{{cell.level}}>
+{% set source = cell.source | replace(' ','_') %}
+<a class="heading-anchor" id="{{source}}" href="#{{source}}">
+  {{cell.source}}
+</a>
+</h{{cell.level}}>
+</div>
+{% endblock headingcell %}
+
+{% block rawcell scoped %}
+{{ cell.source }}
+{% endblock rawcell %}
+
+{% block unknowncell scoped %}
+unknown type  {{cell.type}}
+{% endblock unknowncell %}
+
+
+{% block pyout -%}
+<div class="box-flex1 output_subarea output_pyout">
+{% block data_priority scoped %}{{ super()}}{% endblock %}
+</div>
+{%- endblock pyout %}
+
+{% block stream_stdout -%}
+<div class="box-flex1 output_subarea output_stream output_stdout">
+<pre>{{output.text |ansi2html}}</pre>
+</div>
+{%- endblock stream_stdout %}
+
+{% block stream_stderr -%}
+<div class="box-flex1 output_subarea output_stream output_stderr">
+<pre>{{output.text |ansi2html}}</pre>
+</div>
+{%- endblock stream_stderr %}
+
+{% block data_svg -%}
+{{output.svg}}
+{%- endblock data_svg %}
+
+
+{% block data_html -%}
+<div class="output_html rendered_html">
+{{output.html}}
+</div>
+{%- endblock data_html %}
+
+{% block data_png %}
+<img src="data:image/png;base64,{{output.png}}">
+{%- endblock data_png %}
+
+
+{% block data_jpg %}
+<img src="data:image/jpeg;base64,{{output.jpeg}}">
+{%- endblock data_jpg %}
+
+
+{% block data_latex %}
+{{output.latex}}
+{%- endblock data_latex %}
+
+{% block pyerr -%}
+<div class="box-flex1 output_subarea output_pyerr">
+<pre>{{super()}}</pre>
+</div>
+{%- endblock pyerr %}
+
+{%- block traceback_line %}
+{{line| ansi2html}}
+{%- endblock traceback_line %}
+
+
+{%- block data_text %}
+<pre>{{output.text | ansi2html}}</pre>
+{%- endblock -%}
+
+
+{%- block display_data scoped -%}
+<div class="box-flex1 output_subarea output_display_data">
+{{super()}}
+</div>
+{%- endblock display_data -%}

IPython/nbconvert/templates/fullhtml.tpl

@@ -0,0 +1,64 b''
+{%- extends 'basichtml.tpl' -%}
+
+{%- block header -%}<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8">
+<title>[{{nb.metadata.name}}]</title>
+{% for css in resources.inlining.css -%}
+<style type="text/css">
+{{css}}
+</style>
+{% endfor %}
+
+<style type="text/css">
+/* Overrides of notebook CSS for static HTML export */
+body {
+  overflow: visible;
+  padding: 8px;
+}
+.input_area {
+  padding: 0.2em;
+}
+
+pre {
+    border: none;
+    margin: 0px;
+    font-size: 13px;
+}
+</style>
+
+<script src="https://c328740.ssl.cf1.rackcdn.com/mathjax/latest/MathJax.js?config=TeX-AMS_HTML" type="text/javascript">
+
+</script>
+<script type="text/javascript">
+init_mathjax = function() {
+    if (window.MathJax) {
+        // MathJax loaded
+        MathJax.Hub.Config({
+            tex2jax: {
+                inlineMath: [ ['$','$'], ["\\(","\\)"] ],
+                displayMath: [ ['$$','$$'], ["\\[","\\]"] ]
+            },
+            displayAlign: 'left', // Change this to 'center' to center equations.
+            "HTML-CSS": {
+                styles: {'.MathJax_Display': {"margin": 0}}
+            }
+        });
+        MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
+    }
+}
+init_mathjax();
+</script>
+</head>
+{%- endblock header -%}
+
+
+{% block body %}
+<body>{{ super() }}
+</body>
+{%- endblock body %}
+
+
+{% block footer %}
+</html>{% endblock footer %}

IPython/nbconvert/templates/latex/base.tplx

@@ -0,0 +1,263 b''
+((*- extends 'display_priority.tplx' -*))
+
+((* block in_prompt *))((* endblock in_prompt *))
+
+((* block output_prompt *))((* endblock output_prompt *))
+
+((* block codecell *))\begin{codecell}((( super() )))
+\end{codecell}
+((* endblock *))
+
+((* block input *))
+\begin{codeinput}
+\begin{lstlisting}
+((( cell.input )))
+\end{lstlisting}
+\end{codeinput}
+((* endblock input *))
+
+
+((= Those Two are for error displaying
+even if the first one seem to do nothing, 
+it introduces a new line
+
+=))
+((* block pyerr *))
+\begin{traceback}
+\begin{verbatim}((( super() )))
+\end{verbatim}
+\end{traceback}
+((* endblock pyerr *))
+
+((* block traceback_line *))
+((( line |indent| rm_ansi )))((* endblock traceback_line *))
+((= .... =))
+
+
+((*- block output_group -*))
+\begin{codeoutput}
+((( super() )))
+\end{codeoutput}((* endblock *))
+
+((*- block data_png -*))
+\begin{center}
+\includegraphics[width=0.7\textwidth, height=0.9\textheight, keepaspectratio]{(((output.key_png)))}
+\par
+\end{center}
+((*- endblock -*))
+
+((*- block data_jpg -*))
+\begin{center}
+\includegraphics[width=0.7\textwidth, height=0.9\textheight, keepaspectratio]{(((output.key_jpeg)))}
+\par
+\end{center}
+((*- endblock -*))
+
+((*- block data_svg -*))
+\begin{center}
+\includegraphics[width=0.7\textwidth]{(((output.key_svg)))}
+\par
+\end{center}
+((*- endblock -*))
+
+((* block pyout *))
+((* block data_priority scoped *))((( super() )))((* endblock *))
+((* endblock pyout *))
+
+((* block data_text *))
+\begin{verbatim}
+((( output.text )))
+\end{verbatim}
+((* endblock *))
+
+((* block data_latex -*))
+((*- if output.latex.startswith('$'): -*)) \begin{equation*}
+    ((( output.latex | rm_dollars)))
+    \end{equation*}
+((*- else -*)) ((( output.latex ))) ((*- endif *))
+((* endblock *))
+
+((* block stream *))
+\begin{Verbatim}[commandchars=\\\{\}]
+((( output.text | ansi2latex)))
+\end{Verbatim}
+((* endblock stream *))
+
+((* block markdowncell scoped *))((( cell.source | markdown2latex )))
+((* endblock markdowncell *))
+
+((* block headingcell scoped -*))
+    \
+    ((*- if cell.level == 1 -*))
+        ((* block h1 -*))section((* endblock h1 -*))
+    ((*- elif cell.level == 2 -*))
+        ((* block h2 -*))subsection((* endblock h2 -*))
+    ((*- elif cell.level == 3 -*))
+        ((* block h3 -*))subsubsection((* endblock h3 -*))
+    ((*- elif cell.level == 4 -*))
+        ((* block h4 -*))paragraph((* endblock h4 -*))
+    ((*- elif cell.level == 5 -*))
+        ((* block h5 -*))subparagraph((* endblock h5 -*))
+    ((*- elif cell.level == 6 -*))
+        ((* block h6 -*))subparagraph((* endblock h6 -*))
+        ((= 6th level not available in standard latex =))
+
+    ((*- endif -*)){((( cell.source | markdown2latex )))}
+((* endblock headingcell *))
+
+((* block rawcell scoped *))
+((( cell.source | pycomment )))
+((* endblock rawcell *))
+
+((* block unknowncell scoped *))
+unknown type  (((cell.type)))
+((* endblock unknowncell *))
+
+
+
+((* block body *))
+
+((* block bodyBegin *))
+\begin{document}
+((* endblock bodyBegin *))
+
+((( super() )))
+
+((* block bodyEnd *))
+\end{document}
+((* endblock bodyEnd *))
+((* endblock body *))
+
+((* block header *))
+%% This file was auto-generated by IPython.
+%% Conversion from the original notebook file:
+%%
+\documentclass[11pt,english]{article}
+
+%% This is the automatic preamble used by IPython.  Note that it does *not*
+%% include a documentclass declaration, that is added at runtime to the overall
+%% document.
+
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage{graphicx}
+\usepackage{ucs}
+\usepackage[utf8x]{inputenc}
+
+%fancy verbatim
+\usepackage{fancyvrb}
+% needed for markdown enumerations to work
+\usepackage{enumerate}
+
+% Slightly bigger margins than the latex defaults
+\usepackage{geometry}
+\geometry{verbose,tmargin=3cm,bmargin=3cm,lmargin=2.5cm,rmargin=2.5cm}
+
+% Define a few colors for use in code, links and cell shading
+\usepackage{color}
+\definecolor{orange}{cmyk}{0,0.4,0.8,0.2}
+\definecolor{darkorange}{rgb}{.71,0.21,0.01}
+\definecolor{darkgreen}{rgb}{.12,.54,.11}
+\definecolor{myteal}{rgb}{.26, .44, .56}
+\definecolor{gray}{gray}{0.45}
+\definecolor{lightgray}{gray}{.95}
+\definecolor{mediumgray}{gray}{.8}
+\definecolor{inputbackground}{rgb}{.95, .95, .85}
+\definecolor{outputbackground}{rgb}{.95, .95, .95}
+\definecolor{traceback}{rgb}{1, .95, .95}
+
+% new ansi colors
+\definecolor{brown}{rgb}{0.54,0.27,0.07}
+\definecolor{purple}{rgb}{0.5,0.0,0.5}
+\definecolor{darkgray}{gray}{0.25}
+\definecolor{lightred}{rgb}{1.0,0.39,0.28}
+\definecolor{lightgreen}{rgb}{0.48,0.99,0.0}
+\definecolor{lightblue}{rgb}{0.53,0.81,0.92}
+\definecolor{lightpurple}{rgb}{0.87,0.63,0.87}
+\definecolor{lightcyan}{rgb}{0.5,1.0,0.83}
+
+% Framed environments for code cells (inputs, outputs, errors, ...).  The
+% various uses of \unskip (or not) at the end were fine-tuned by hand, so don't
+% randomly change them unless you're sure of the effect it will have.
+\usepackage{framed}
+
+% remove extraneous vertical space in boxes
+\setlength\fboxsep{0pt}
+
+% codecell is the whole input+output set of blocks that a Code cell can
+% generate.
+
+% TODO: unfortunately, it seems that using a framed codecell environment breaks
+% the ability of the frames inside of it to be broken across pages.  This
+% causes at least the problem of having lots of empty space at the bottom of
+% pages as new frames are moved to the next page, and if a single frame is too
+% long to fit on a page, will completely stop latex from compiling the
+% document.  So unless we figure out a solution to this, we'll have to instead
+% leave the codecell env. as empty.  I'm keeping the original codecell
+% definition here (a thin vertical bar) for reference, in case we find a
+% solution to the page break issue.
+
+%% \newenvironment{codecell}{%
+%%     \def\FrameCommand{\color{mediumgray} \vrule width 1pt \hspace{5pt}}%
+%%    \MakeFramed{\vspace{-0.5em}}}
+%%  {\unskip\endMakeFramed}
+
+% For now, make this a no-op...
+\newenvironment{codecell}{}
+
+ \newenvironment{codeinput}{%
+   \def\FrameCommand{\colorbox{inputbackground}}%
+   \MakeFramed{\advance\hsize-\width \FrameRestore}}
+ {\unskip\endMakeFramed}
+
+\newenvironment{codeoutput}{%
+   \def\FrameCommand{\colorbox{outputbackground}}%
+   \vspace{-1.4em}
+   \MakeFramed{\advance\hsize-\width \FrameRestore}}
+ {\unskip\medskip\endMakeFramed}
+
+\newenvironment{traceback}{%
+   \def\FrameCommand{\colorbox{traceback}}%
+   \MakeFramed{\advance\hsize-\width \FrameRestore}}
+ {\endMakeFramed}
+
+% Use and configure listings package for nicely formatted code
+\usepackage{listingsutf8}
+\lstset{
+  language=python,
+  inputencoding=utf8x,
+  extendedchars=\true,
+  aboveskip=\smallskipamount,
+  belowskip=\smallskipamount,
+  xleftmargin=2mm,
+  breaklines=true,
+  basicstyle=\small \ttfamily,
+  showstringspaces=false,
+  keywordstyle=\color{blue}\bfseries,
+  commentstyle=\color{myteal},
+  stringstyle=\color{darkgreen},
+  identifierstyle=\color{darkorange},
+  columns=fullflexible,  % tighter character kerning, like verb
+}
+
+% The hyperref package gives us a pdf with properly built
+% internal navigation ('pdf bookmarks' for the table of contents,
+% internal cross-reference links, web links for URLs, etc.)
+\usepackage{hyperref}
+\hypersetup{
+  breaklinks=true,  % so long urls are correctly broken across lines
+  colorlinks=true,
+  urlcolor=blue,
+  linkcolor=darkorange,
+  citecolor=darkgreen,
+  }
+
+% hardcode size of all verbatim environments to be a bit smaller
+\makeatletter 
+\g@addto@macro\@verbatim\small\topsep=0.5em\partopsep=0pt
+\makeatother 
+
+% Prevent overflowing lines due to urls and other hard-to-break entities.
+\sloppy
+
+((* endblock *))

IPython/nbconvert/templates/latex/skeleton/display_priority.tplx

@@ -0,0 +1,39 b''
+((= autogenerated file do not edit =))
+((*- extends 'null.tplx' -*))
+
+((=display data priority=))
+
+
+((*- block data_priority scoped -*))
+    ((*- for type in output | filter_data_type -*))
+        ((*- if type in ['pdf']*))
+            ((*- block data_pdf -*))
+            ((*- endblock -*))
+        ((*- endif -*))
+        ((*- if type in ['svg']*))
+            ((*- block data_svg -*))
+            ((*- endblock -*))
+        ((*- endif -*))
+        ((*- if type in ['png']*))
+            ((*- block data_png -*))
+            ((*- endblock -*))
+        ((*- endif -*))
+        ((*- if type in ['html']*))
+            ((*- block data_html -*))
+            ((*- endblock -*))
+        ((*- endif -*))
+        ((*- if type in ['jpeg']*))
+            ((*- block data_jpg -*))
+            ((*- endblock -*))
+        ((*- endif -*))
+        ((*- if type in ['text']*))
+            ((*- block data_text -*))
+            ((*- endblock -*))
+        ((*- endif -*))
+
+        ((*- if type in ['latex']*))
+            ((*- block data_latex -*))
+            ((*- endblock -*))
+        ((*- endif -*))
+    ((*- endfor -*))
+((*- endblock data_priority -*))

IPython/nbconvert/templates/latex/skeleton/null.tplx

@@ -0,0 +1,92 b''
+((= autogenerated file do not edit =))
+((=
+
+DO NOT USE THIS AS A BASE WORK,
+IF YOU ARE COPY AND PASTING THIS FILE
+YOU ARE PROBABLY DOING THINGS WRONG.
+
+Null template, Does nothing except defining a basic structure
+To layout the different blocks of a notebook.
+
+Subtemplates can override blocks to define their custom representation.
+
+If one of the block you do overwrite is not a leave block, consider
+calling super.
+
+((*- block nonLeaveBlock -*))
+    #add stuff at beginning
+    ((( super() )))
+    #add stuff at end
+((*- endblock nonLeaveBlock -*))
+
+consider calling super even if it is a leave block, we might insert more blocks later.
+
+=))
+((*- block header -*))
+((*- endblock header -*))
+((*- block body -*))
+((*- for worksheet in nb.worksheets -*))
+    ((*- for cell in worksheet.cells -*))
+        ((*- block any_cell scoped -*))
+            ((*- if cell.cell_type in ['code'] -*))
+                ((*- block codecell scoped -*))
+                    ((*- block input_group -*))
+                        ((*- block in_prompt -*))((*- endblock in_prompt -*))
+                        ((*- block input -*))((*- endblock input -*))
+                    ((*- endblock input_group -*))
+                    ((*- if cell.outputs -*))
+                    ((*- block output_group -*))
+                        ((*- block output_prompt -*))((*- endblock output_prompt -*))
+                        ((*- block outputs scoped -*))
+                            ((*- for output in cell.outputs -*))
+                                ((*- block output scoped -*))
+                                    ((*- if output.output_type in ['pyout'] -*))
+                                        ((*- block pyout scoped -*))((*- endblock pyout -*))
+                                    ((*- elif output.output_type in ['stream'] -*))
+                                        ((*- block stream scoped -*))
+                                            ((*- if output.stream in ['stdout'] -*))
+                                                ((*- block stream_stdout scoped -*))
+                                                ((*- endblock stream_stdout -*))
+                                            ((*- elif output.stream in ['stderr'] -*))
+                                                ((*- block stream_stderr scoped -*))
+                                                ((*- endblock stream_stderr -*))
+                                            ((*- endif -*))
+                                        ((*- endblock stream -*))
+                                    ((*- elif output.output_type in ['display_data'] -*))
+                                        ((*- block display_data scoped -*))
+                                            ((*- block data_priority scoped -*))
+                                            ((*- endblock data_priority -*))
+                                        ((*- endblock display_data -*))
+                                    ((*- elif output.output_type in ['pyerr'] -*))
+                                        ((*- block pyerr scoped -*))
+                                        ((*- for line in output.traceback -*))
+                                            ((*- block traceback_line scoped -*))((*- endblock traceback_line -*))
+                                        ((*- endfor -*))
+                                        ((*- endblock pyerr -*))
+                                    ((*- endif -*))
+                                ((*- endblock output -*))
+                            ((*- endfor -*))
+                        ((*- endblock outputs -*))
+                    ((*- endblock output_group -*))
+                    ((*- endif -*))
+                ((*- endblock codecell -*))
+            ((*- elif cell.cell_type in ['markdown'] -*))
+                ((*- block markdowncell scoped-*))
+                ((*- endblock markdowncell -*))
+            ((*- elif cell.cell_type in ['heading'] -*))
+                ((*- block headingcell scoped-*))
+                ((*- endblock headingcell -*))
+            ((*- elif cell.cell_type in ['raw'] -*))
+                ((*- block rawcell scoped-*))
+                ((*- endblock rawcell -*))
+            ((*- else -*))
+                ((*- block unknowncell scoped-*))
+                ((*- endblock unknowncell -*))
+            ((*- endif -*))
+        ((*- endblock any_cell -*))
+    ((*- endfor -*))
+((*- endfor -*))
+((*- endblock body -*))
+
+((*- block footer -*))
+((*- endblock footer -*))

IPython/nbconvert/templates/latex/sphinx_base.tplx

@@ -0,0 +1,442 b''
+((= NBConvert Sphinx-Latex Template
+
+Purpose: Allow export of PDF friendly Latex inspired by Sphinx.  Most of the
+       template is derived directly from Sphinx source.
+
+Inheritance: null>display_priority 
+
+Note: For best display, use latex syntax highlighting. =))
+
+((*- extends 'display_priority.tplx' -*))
+
+%==============================================================================
+% Declarations
+%==============================================================================
+
+% In order to make sure that the input/output header follows the code it 
+% preceeds, the needspace package is used to request that a certain
+% amount of lines (specified by this variable) are reserved.  If those
+% lines aren't available on the current page, the documenter will break
+% to the next page and the header along with accomanying lines will be
+% rendered together.  This value specifies the number of lines that
+% the header will be forced to group with without a page break.
+((*- set min_header_lines = 4 -*))
+
+% This is the number of characters that are permitted per line.  It's
+% important that this limit is set so characters do not run off the
+% edges of latex pages (since latex does not always seem smart enough
+% to prevent this in some cases.)  This is only applied to textual output
+((* if resources.sphinx.outputstyle == 'simple' *))
+    ((*- set wrap_size = 85 -*))
+((* elif resources.sphinx.outputstyle == 'notebook' *))
+    ((*- set wrap_size = 70 -*))
+((* endif *))
+
+%==============================================================================
+% Header
+%==============================================================================
+((* block header *))
+
+% Header, overrides base
+
+    % Make sure that the sphinx doc style knows who it inherits from.
+    \def\sphinxdocclass{(((parentdocumentclass)))}
+
+    % Declare the document class
+    \documentclass[letterpaper,10pt,english]{((( resources.sphinx.texinputs )))/sphinx(((documentclass)))}
+
+    % Imports
+    \usepackage[utf8]{inputenc}
+    \DeclareUnicodeCharacter{00A0}{\\nobreakspace}
+    \usepackage[T1]{fontenc}
+    \usepackage{babel}
+    \usepackage{times}
+    \usepackage{import}
+    \usepackage[((( resources.sphinx.chapterstyle )))]{((( resources.sphinx.texinputs )))/fncychap}
+    \usepackage{longtable}
+    \usepackage{((( resources.sphinx.texinputs )))/sphinx}
+    \usepackage{multirow}
+
+    \usepackage{amsmath}
+    \usepackage{amssymb}
+    \usepackage{ucs}
+    \usepackage{enumerate}
+
+    % Used to make the Input/Output rules follow around the contents.
+    \usepackage{needspace}
+
+    % Pygments requirements
+    \usepackage{fancyvrb}
+    \usepackage{color}
+    % ansi colors additions
+    \definecolor{darkgreen}{rgb}{.12,.54,.11}
+    \definecolor{lightgray}{gray}{.95}
+    \definecolor{brown}{rgb}{0.54,0.27,0.07}
+    \definecolor{purple}{rgb}{0.5,0.0,0.5}
+    \definecolor{darkgray}{gray}{0.25}
+    \definecolor{lightred}{rgb}{1.0,0.39,0.28}
+    \definecolor{lightgreen}{rgb}{0.48,0.99,0.0}
+    \definecolor{lightblue}{rgb}{0.53,0.81,0.92}
+    \definecolor{lightpurple}{rgb}{0.87,0.63,0.87}
+    \definecolor{lightcyan}{rgb}{0.5,1.0,0.83}
+
+    % Needed to box output/input
+    \usepackage{tikz}
+        \usetikzlibrary{calc,arrows,shadows}
+    \usepackage[framemethod=tikz]{mdframed}
+
+    \usepackage{alltt}
+
+    % Used to load and display graphics
+    \usepackage{graphicx}
+    \graphicspath{ {figs/} }
+    \usepackage[Export]{adjustbox} % To resize
+
+
+    % For formatting output while also word wrapping.
+    \usepackage{listings}
+    \lstset{breaklines=true}
+    \lstset{basicstyle=\small\ttfamily}
+    \def\smaller{\fontsize{9.5pt}{9.5pt}\selectfont}
+
+    %Pygments definitions
+    ((( resources.sphinx.pygment_definitions )))
+
+    %Set pygments styles if needed...
+    ((* if resources.sphinx.outputstyle == 'notebook' *))
+        \definecolor{nbframe-border}{rgb}{0.867,0.867,0.867}
+        \definecolor{nbframe-bg}{rgb}{0.969,0.969,0.969}
+        \definecolor{nbframe-in-prompt}{rgb}{0.0,0.0,0.502}
+        \definecolor{nbframe-out-prompt}{rgb}{0.545,0.0,0.0}
+
+        \newenvironment{ColorVerbatim}
+        {\begin{mdframed}[%
+            roundcorner=1.0pt, %
+            backgroundcolor=nbframe-bg, %
+            userdefinedwidth=1\linewidth, %
+            leftmargin=0.1\linewidth, %
+            innerleftmargin=0pt, %
+            innerrightmargin=0pt, %
+            linecolor=nbframe-border, %
+            linewidth=1pt, %
+            usetwoside=false, %
+            everyline=true, %
+            innerlinewidth=3pt, %
+            innerlinecolor=nbframe-bg, %
+            middlelinewidth=1pt, %
+            middlelinecolor=nbframe-bg, %
+            outerlinewidth=0.5pt, %
+            outerlinecolor=nbframe-border, %
+            needspace=0pt
+        ]}
+        {\end{mdframed}}
+        
+        \newenvironment{InvisibleVerbatim}
+        {\begin{mdframed}[leftmargin=0.1\linewidth,innerleftmargin=3pt,innerrightmargin=3pt, userdefinedwidth=1\linewidth, linewidth=0pt, linecolor=white, usetwoside=false]}
+        {\end{mdframed}}
+
+        \renewenvironment{Verbatim}[1][\unskip]
+        {\begin{alltt}\smaller}
+        {\end{alltt}}
+    ((* endif *))
+
+    % Help prevent overflowing lines due to urls and other hard-to-break 
+    % entities.  This doesn't catch everything...
+    \sloppy
+
+    % Document level variables
+    \title{((( nb.metadata.name | escape_tex )))}
+    \date{((( nb.metadata._draft.date | escape_tex )))}
+    \release{((( nb.metadata._draft.version | escape_tex )))}
+    \author{((( nb.metadata._draft.author | escape_tex )))}
+    \renewcommand{\releasename}{((( nb.metadata._draft.release | escape_tex )))}
+
+    % TODO: Add option for the user to specify a logo for his/her export.
+    \newcommand{\sphinxlogo}{}
+
+    % Make the index page of the document.
+    \makeindex
+
+    % Import sphinx document type specifics.
+    ((* block sphinxheader *))((* endblock sphinxheader *)) 
+((* endblock header *))
+
+%==============================================================================
+% Body
+%==============================================================================
+((* block body *))
+((* block bodyBegin *))
+% Body
+
+    % Start of the document
+    \begin{document}
+
+        ((* if resources.sphinx.header *))
+            \maketitle
+        ((* endif *))
+
+        ((* block toc *))
+            \tableofcontents 
+        ((* endblock toc *))
+
+        ((* endblock bodyBegin *))((( super() )))((* block bodyEnd *))
+
+        \renewcommand{\indexname}{Index}
+        \printindex
+
+    % End of document
+    \end{document}
+((* endblock bodyEnd *))
+((* endblock body *))
+
+%==============================================================================
+% Footer
+%==============================================================================
+((* block footer *))
+((* endblock footer *))
+
+%==============================================================================
+% Headings
+%
+% Purpose: Format pynb headers as sphinx headers.  Depending on the Sphinx
+%          style that is active, this will change.  Thus sphinx styles will
+%          override the values here.
+%==============================================================================
+((* block headingcell -*))
+    \
+    ((*- if cell.level == 1 -*))
+        ((* block h1 -*))part((* endblock h1 -*))
+    ((*- elif cell.level == 2 -*))
+        ((* block h2 -*))chapter((* endblock h2 -*))
+    ((*- elif cell.level == 3 -*))
+        ((* block h3 -*))section((* endblock h3 -*))
+    ((*- elif cell.level == 4 -*))
+        ((* block h4 -*))subsection((* endblock h4 -*))
+    ((*- elif cell.level == 5 -*))
+        ((* block h5 -*))subsubsection((* endblock h5 -*))
+    ((*- elif cell.level == 6 -*))
+        ((* block h6 -*))paragraph((* endblock h6 -*))
+
+    ((= It's important to make sure that underscores (which tend to be common
+    in IPYNB file titles) do not make their way into latex.  Sometimes this
+    causes latex to barf. =))
+    ((*- endif -*)){((( cell.source | markdown2latex )))}
+((*- endblock headingcell *))
+
+%==============================================================================
+% Markdown
+%
+% Purpose: Convert markdown to latex.  Here markdown2latex is explicitly
+%          called since we know we want latex output.
+%==============================================================================
+((*- block markdowncell scoped-*))
+    ((( cell.source | markdown2latex )))
+((*- endblock markdowncell -*))
+
+%==============================================================================
+% Rawcell
+%
+% Purpose: Raw text cells allow the user to manually inject document code that 
+%          will not get touched by the templating system.
+%==============================================================================
+((*- block rawcell *))
+    ((( cell.source | wrap(wrap_size) )))
+((* endblock rawcell -*))
+
+%==============================================================================
+% Unknowncell
+%
+% Purpose: This is the catch anything unhandled.  To display this data, we
+%          remove all possible latex conflicts and wrap the characters so they
+%          can't flow off of the page.
+%==============================================================================
+((* block unknowncell scoped*))
+
+    % Unsupported cell type, no formatting
+    ((( cell.source | wrap | escape_tex )))
+((* endblock unknowncell *))
+
+%==============================================================================
+% Input
+%==============================================================================
+((* block input *))
+
+    % Make sure that atleast 4 lines are below the HR
+    \needspace{((( min_header_lines )))\baselineskip}
+
+    ((* if resources.sphinx.outputstyle == 'simple' *))
+
+        % Add a horizantal break, along with break title.
+        \vspace{10pt}
+        {\scriptsize Input}\\*
+        \rule[10pt]{\linewidth}{0.5pt}
+        \vspace{-25pt}
+
+        % Add contents below.
+        ((( cell.input | highlight )))
+
+    ((* elif resources.sphinx.outputstyle == 'notebook' *))
+        \vspace{6pt}
+        ((( write_prompt("In", cell.prompt_number, "nbframe-in-prompt") )))
+        \vspace{-2.65\baselineskip}
+        \begin{ColorVerbatim}
+            \vspace{-0.7\baselineskip}
+            ((( cell.input | highlight )))
+            ((* if cell.input == None or cell.input == '' *))
+                \vspace{0.3\baselineskip}
+            ((* else *))
+                \vspace{-0.2\baselineskip}
+            ((* endif *))
+        \end{ColorVerbatim}
+    ((* endif *))
+((* endblock input *))
+
+%==============================================================================
+% Output_Group
+%
+% Purpose: Make sure that only one header bar only attaches to the output 
+%          once.  By keeping track of when an input group is started
+%==============================================================================
+((* block output_group *))
+    ((* if cell.outputs.__len__() > 0 *))
+
+        % If the first block is an image, minipage the image.  Else
+        % request a certain amount of space for the input text.
+        ((( iff_figure(cell.outputs[0], "\\begin{minipage}{1.0\\textwidth}", "\\needspace{"  ~ min_header_lines ~ "\\baselineskip}") )))
+        
+        ((* if resources.sphinx.outputstyle == 'simple' *))
+
+            % Add a horizantal break, along with break title.
+            \vspace{10pt}
+            {\scriptsize Output}\\*
+            \rule[10pt]{\linewidth}{0.5pt}
+            \vspace{-20pt}
+
+            % Add the contents of the first block.
+            ((( render_output(cell.outputs[0]) )))
+
+            % Close the minipage.
+            ((( iff_figure(cell.outputs[0], "\\end{minipage}", "") )))
+
+            % Add remainer of the document contents below.
+            ((* for output in cell.outputs[1:] *))
+                ((( render_output(output, cell.prompt_number) )))
+            ((* endfor *))
+        ((* elif resources.sphinx.outputstyle == 'notebook' *))
+
+            % Add document contents.
+            ((* for output in cell.outputs *))
+                ((( render_output(output, cell.prompt_number) )))
+            ((* endfor *))
+        ((* endif *))
+    ((* endif *))
+((* endblock *))
+
+%==============================================================================
+% Additional formating
+%==============================================================================
+((* block data_text *))
+    ((( custom_verbatim(output.text) | ansi2latex)))
+((* endblock *))
+
+((* block traceback_line *))
+    ((( conditionally_center_output(line | indent| rm_ansi) )))
+((* endblock traceback_line *))
+
+%==============================================================================
+% Supported image formats
+%==============================================================================
+((*- block data_png -*))
+    ((( conditionally_center_output(insert_graphics(output.key_png)) )))
+((*- endblock -*))
+
+((*- block data_svg -*))
+    ((( conditionally_center_output(insert_graphics(output.key_svg)) )))
+((*- endblock -*))
+
+((*- block data_latex *))
+    ((* if resources.sphinx.centeroutput *))\begin{center}((* endif -*))((( output.latex | rm_math_space )))((*- if resources.sphinx.centeroutput *))\end{center} ((* endif -*))
+((*- endblock -*))
+
+%==============================================================================
+% Support Macros
+%==============================================================================
+
+% Name: write_prompt
+% Purpose: Renders an output/input prompt for notebook style pdfs
+((* macro write_prompt(prompt, number, color) -*))
+    \makebox[0.1\linewidth]{\smaller\hfill\tt\color{((( color )))}((( prompt )))\hspace{4pt}{[}((( number ))){]}:\hspace{4pt}}\\*
+((*- endmacro *))
+
+% Name: render_output
+% Purpose: Renders an output block appropriately.
+((* macro render_output(output, prompt_number) -*))
+    ((*- if output.output_type == 'pyerr' -*))
+        ((*- block pyerr scoped *))
+            ((( custom_verbatim(super()) )))
+        ((* endblock pyerr -*))
+    ((*- else -*))
+
+        ((* if resources.sphinx.outputstyle == 'notebook' *))
+            ((*- if output.output_type == 'pyout' -*))
+                ((( write_prompt("Out", prompt_number, "nbframe-out-prompt") )))
+                \vspace{-2.55\baselineskip}
+            ((*- endif -*))
+
+            \begin{InvisibleVerbatim}
+                \vspace{-0.5\baselineskip}
+        ((*- endif -*))
+
+        ((*- block display_data scoped -*))
+            ((( super() )))
+        ((*- endblock display_data -*))
+
+        ((* if resources.sphinx.outputstyle == 'notebook' *))
+            \end{InvisibleVerbatim}
+        ((*- endif -*))
+    ((*- endif -*))
+((*- endmacro *))
+
+% Name: iff_figure
+% Purpose: If the output block provided is a figure type, the 'true_content'
+%          parameter will be returned.  Else, the 'false_content'. 
+((* macro iff_figure(output, true_content, false_content) -*))
+    ((*- set is_figure = false -*))
+    ((*- for type in output | filter_data_type -*))
+        ((*- if type in ['pdf', 'svg', 'png', 'jpeg','html']*))
+            ((*- set is_figure = true -*))
+        ((*- endif -*))
+    ((*- endfor -*))
+    
+    ((* if is_figure -*))
+        ((( true_content )))
+    ((*- else -*))
+        ((( false_content )))
+    ((*- endif *))
+((*- endmacro *))
+
+% Name: custom_verbatim
+% Purpose: This macro creates a verbatim style block that fits the existing
+%          sphinx style more readily than standard verbatim blocks.
+((* macro custom_verbatim(text) -*))
+    \begin{alltt}
+    ((*- if resources.sphinx.centeroutput *))\begin{center} ((* endif -*))
+((( text | wrap(wrap_size) )))
+    ((*- if resources.sphinx.centeroutput *))\end{center}((* endif -*))
+    \end{alltt}
+((*- endmacro *))
+
+% Name: conditionally_center_output
+% Purpose: This macro centers the output if the output centering is enabled.
+((* macro conditionally_center_output(text) -*))
+    ((* if resources.sphinx.centeroutput *)){\centering ((* endif *))((( text )))((* if resources.sphinx.centeroutput *))}((* endif *))
+((*- endmacro *))
+
+% Name: insert_graphics
+% Purpose: This macro will insert an image in the latex document given a path.
+((* macro insert_graphics(path) -*))
+    \begin{center}
+    \includegraphics[max size={\textwidth}{\textheight}]{(((path)))}
+    \par
+    \end{center}
+((*- endmacro *))

IPython/nbconvert/templates/latex/sphinx_howto.tplx

@@ -0,0 +1,25 b''
+((============================================================================
+  NBConvert Sphinx-Latex HowTo Template
+
+  Purpose: Allow export of PDF friendly Latex inspired by Sphinx HowTo 
+           document style.  Most of the is derived directly from Sphinx source.
+
+  Inheritance: null>display_priority>latex_base->latex_sphinx_base 
+
+  ==========================================================================))
+
+((*- extends 'sphinx_base.tplx' -*))
+
+((* set parentdocumentclass = 'article' *))
+((* set documentclass = 'howto' *))
+
+((* block h1 -*))part((* endblock h1 -*))
+((* block h2 -*))section((* endblock h2 -*))
+((* block h3 -*))subsection((* endblock h3 -*))
+((* block h4 -*))subsubsection((* endblock h4 -*))
+((* block h5 -*))paragraph((* endblock h5 -*))
+((* block h6 -*))subparagraph((* endblock h6 -*))
+
+% Diasble table of contents for howto
+((* block toc *))
+((* endblock toc *))

IPython/nbconvert/templates/latex/sphinx_manual.tplx

@@ -0,0 +1,21 b''
+((============================================================================
+  NBConvert Sphinx-Latex Manual Template
+
+  Purpose: Allow export of PDF friendly Latex inspired by Sphinx Manual 
+           document style.  Most of the is derived directly from Sphinx source.
+
+  Inheritance: null>display_priority>latex_base->latex_sphinx_base 
+
+  ==========================================================================))
+
+((*- extends 'sphinx_base.tplx' -*))
+
+((* set parentdocumentclass = 'report' *))
+((* set documentclass = 'manual' *))
+
+((* block h1 -*))part((* endblock h1 -*))
+((* block h2 -*))chapter((* endblock h2 -*))
+((* block h3 -*))section((* endblock h3 -*))
+((* block h4 -*))subsection((* endblock h4 -*))
+((* block h5 -*))subsubsection((* endblock h5 -*))
+((* block h6 -*))paragraph((* endblock h6 -*))

IPython/nbconvert/templates/markdown.tpl

@@ -0,0 +1,73 b''
+{% extends 'display_priority.tpl' %}
+{% block in_prompt %}
+In[{{cell.prompt_number if cell.prompt_number else ' '}}]:{% endblock in_prompt %}
+
+{% block output_prompt %}{% if cell.haspyout %}Out[{{cell.prompt_number}}]:
+{%- endif %}{%- endblock output_prompt %}
+
+{% block input %}
+```
+{{ cell.input}}
+```
+{% endblock input %}
+
+{% block pyerr %}
+{{ super() }}
+{% endblock pyerr %}
+
+{% block traceback_line %}
+{{ line |indent| rm_ansi }}{% endblock traceback_line %}
+
+{% block pyout %}
+{% block data_priority scoped %}{{ super()}}{% endblock %}
+{% endblock pyout %}
+
+{% block stream %}
+{{ output.text| indent }}
+{% endblock stream %}
+
+
+
+
+{% block data_svg %}
+[!image]({{output.key_svg}})
+{% endblock data_svg %}
+
+{% block data_png %}
+[!image]({{output.key_png}})
+{% endblock data_png %}
+
+{% block data_jpg %}
+[!image]({{output.key_jpg}})
+{% endblock data_jpg %}
+
+
+
+{% block data_latex %}
+$$
+{{output.latex}}
+$$
+{% endblock data_latex %}
+
+{% block data_text scoped %}
+
+{{output.text | indent}}
+
+{% endblock data_text %}
+
+{% block markdowncell scoped %}
+{{ cell.source | wrap(80)}}
+{% endblock markdowncell %}
+
+{% block headingcell scoped %}
+
+{{ '#' * cell.level }} {{ cell.source}}
+
+{% endblock headingcell %}
+
+{% block rawcell scoped %}{{ cell.source  }}
+{% endblock rawcell %}
+
+{% block unknowncell scoped %}
+unknown type  {{cell.type}}
+{% endblock unknowncell %}

IPython/nbconvert/templates/python.tpl

@@ -0,0 +1,56 b''
+{%- extends 'null.tpl' -%}
+
+{% block in_prompt %}
+# In[{{cell.prompt_number if cell.prompt_number else ' '}}]:
+{% endblock in_prompt %}
+
+{% block output_prompt %}
+# Out[{{cell.prompt_number}}]:{% endblock output_prompt %}
+
+{% block input %}{{ cell.input }}
+{% endblock input %}
+
+
+{# Those Two are for error displaying
+even if the first one seem to do nothing, 
+it introduces a new line
+
+#}
+{% block pyerr %}{{ super() }}
+{% endblock pyerr %}
+
+{% block traceback_line %}
+{{ line |indent| rm_ansi }}{% endblock traceback_line %}
+{# .... #}
+
+
+{% block pyout %}
+{{ output.text| indent | pycomment}}
+{% endblock pyout %}
+
+{% block stream %}
+{{ output.text| indent | pycomment}}
+{% endblock stream %}
+
+
+
+
+{% block display_data scoped %}
+# image file:
+{% endblock display_data %}
+
+{% block markdowncell scoped %}
+{{ cell.source | pycomment }}
+{% endblock markdowncell %}
+
+{% block headingcell scoped %}
+{{ '#' * cell.level }}{{ cell.source | pycomment}}
+{% endblock headingcell %}
+
+{% block rawcell scoped %}
+{{ cell.source | pycomment }}
+{% endblock rawcell %}
+
+{% block unknowncell scoped %}
+unknown type  {{cell.type}}
+{% endblock unknowncell %}

IPython/nbconvert/templates/python_armor.tpl

@@ -0,0 +1,31 b''
+{%- extends 'python.tpl' -%}
+
+{#% block any_cell %}
+==============================
+=======start {{cell.type}}=========
+{{ super() }}
+======= end {{cell.type}} =========
+=============================={% endblock any_cell %#}
+
+
+
+{% block markdowncell %}---- Start MD ----{{ super() }}
+---- End MD ----
+{% endblock markdowncell %}
+
+{% block codecell %}---- Start Code ----{{ super() }}
+---- End Code ----
+{% endblock codecell %}
+
+{% block headingcell scoped %}---- Start heading ----{{ super() }}
+---- End heading ----
+{% endblock headingcell %}
+
+{% block rawcell scoped %}---- Start Raw ----
+{{ super() }}
+---- End Raw ----{% endblock rawcell %}
+
+{% block unknowncell scoped %}
+unknown type  {{cell.type}}
+{% endblock unknowncell %}
+

IPython/nbconvert/templates/reveal.tpl

@@ -0,0 +1,180 b''
+{%- extends 'slides.tpl' -%}
+
+
+{% block header %}
+<!DOCTYPE html>
+<html>
+<head>
+
+<meta charset="utf-8" />
+<meta http-equiv="X-UA-Compatible" content="chrome=1">
+
+<meta name="apple-mobile-web-app-capable" content="yes" />
+<meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
+
+<link rel="stylesheet" href="reveal.js/css/reveal.css">
+<link rel="stylesheet" href="reveal.js/css/theme/simple.css" id="theme">
+
+<!-- For syntax highlighting -->
+<link rel="stylesheet" href="reveal.js/lib/css/zenburn.css">
+
+<!-- If the query includes 'print-pdf', use the PDF print sheet -->
+<script>
+document.write( '<link rel="stylesheet" href="reveal.js/css/print/' + ( window.location.search.match( /print-pdf/gi ) ? 'pdf' : 'paper' ) + '.css" type="text/css" media="print">' );
+</script>
+
+<!--[if lt IE 9]>
+<script src="reveal.js/lib/js/html5shiv.js"></script>
+<![endif]-->
+
+{% for css in resources.inlining.css -%}
+<style type="text/css">
+{{css}}
+</style>
+{% endfor %}
+
+<style type="text/css">
+/* Overrides of notebook CSS for static HTML export */
+.reveal {
+font-size: 20px;
+overflow-y: auto;
+overflow-x: hidden;
+}
+.reveal pre {
+width: 95%;
+padding: 0.4em;
+margin: 0px;
+font-family: monospace, sans-serif;
+font-size: 80%;
+box-shadow: 0px 0px 0px rgba(0, 0, 0, 0);
+}
+.reveal section img {
+border: 0px solid black;
+box-shadow: 0 0 10px rgba(0, 0, 0, 0);
+}
+.reveal .slides {
+text-align: left;
+}
+.reveal.fade {
+opacity: 1;
+}
+div.input_area {
+padding: 0.06em;
+}
+div.code_cell {
+background-color: transparent;
+}
+div.prompt {
+width: 11ex;
+padding: 0.4em;
+margin: 0px;
+font-family: monospace, sans-serif;
+font-size: 80%;
+text-align: right;
+}
+div.output_area pre {
+font-family: monospace, sans-serif;
+font-size: 80%;
+}
+div.output_prompt {
+    /* 5px right shift to account for margin in parent container */
+    margin: 5px 5px 0 -5px;
+}
+.rendered_html p {
+text-align: inherit;
+}
+</style>
+</head>
+{% endblock header%}
+
+
+{% block body %}
+<body>
+<div class="reveal"><div class="slides">
+
+{{ super() }}
+
+</div></div>
+
+<!-- 
+Uncomment the following block and the addthis_widget.js (see below inside dependencies)
+to get enable social buttons.
+-->
+
+<!--
+<div class="addthis_toolbox addthis_floating_style addthis_32x32_style" style="left:20px;top:20px;">
+<a class="addthis_button_twitter"></a>
+<a class="addthis_button_google_plusone_share"></a>
+<a class="addthis_button_linkedin"></a>
+<a class="addthis_button_facebook"></a>
+<a class="addthis_button_more"></a>
+</div>
+-->
+
+<script src="reveal.js/lib/js/head.min.js"></script>
+
+<script src="reveal.js/js/reveal.min.js"></script>
+
+<script>
+
+// Full list of configuration options available here: https://github.com/hakimel/reveal.js#configuration
+Reveal.initialize({
+controls: true,
+progress: true,
+history: true,
+
+theme: Reveal.getQueryHash().theme, // available themes are in /css/theme
+transition: Reveal.getQueryHash().transition || 'linear', // default/cube/page/concave/zoom/linear/none
+
+// Optional libraries used to extend on reveal.js
+dependencies: [
+{ src: 'reveal.js/lib/js/classList.js', condition: function() { return !document.body.classList; } },
+{ src: 'reveal.js/plugin/highlight/highlight.js', async: true, callback: function() { hljs.initHighlightingOnLoad(); } },
+{ src: 'reveal.js/plugin/notes/notes.js', async: true, condition: function() { return !!document.body.classList; } }
+// { src: 'http://s7.addthis.com/js/300/addthis_widget.js', async: true},
+]
+});
+</script>
+
+<!-- MathJax configuration -->
+<script type="text/x-mathjax-config">
+MathJax.Hub.Config({
+    tex2jax: {
+        inlineMath: [ ['$','$'], ["\\(","\\)"] ],
+        displayMath: [ ['$$','$$'], ["\\[","\\]"] ]
+    },
+    displayAlign: 'left', // Change this to 'center' to center equations.
+    "HTML-CSS": {
+        styles: {'.MathJax_Display': {"margin": 0}}
+    }
+});
+</script>
+<!-- End of mathjax configuration -->
+
+<script>
+//  We wait for the onload function to load MathJax after the page is completely loaded.  
+//  MathJax is loaded 1 unit of time after the page is ready.
+//  This hack prevent problems when you load multiple js files (i.e. social button from addthis).
+//
+window.onload = function () {
+  setTimeout(function () {
+    var script = document.createElement("script");
+    script.type = "text/javascript";
+    script.src  = "https://c328740.ssl.cf1.rackcdn.com/mathjax/latest/MathJax.js?config=TeX-AMS_HTML";
+    document.getElementsByTagName("head")[0].appendChild(script);
+  },1)
+}
+</script>
+
+<script>
+Reveal.addEventListener( 'slidechanged', function( event ) {
+MathJax.Hub.Rerender(event.currentSlide);
+});
+</script>
+
+</body>
+{% endblock body %}
+
+{% block footer %}
+</html>
+{% endblock footer %}

IPython/nbconvert/templates/reveal_cells.tpl

@@ -0,0 +1,21 b''
+{%- extends 'basichtml.tpl' -%}
+
+
+
+{%- block any_cell scoped -%}
+{%- if cell.metadata.slide_type in ['-', 'slide', 'subslide'] -%}  
+    {{ super() }}
+{%- elif cell.metadata.slide_type in ['skip'] -%}
+    <div style=display:none>
+    {{ super() }}
+    </div>
+{%- elif cell.metadata.slide_type in ['notes'] -%}
+    <aside class="notes">
+    {{ super() }}
+    </aside>
+{%- elif cell.metadata.slide_type in ['fragment'] -%}
+    <div class="fragment">
+    {{ super() }}
+    </div>    
+{%- endif -%}   
+{%- endblock any_cell -%}

IPython/nbconvert/templates/rst.tpl

@@ -0,0 +1,89 b''
+{%- extends 'display_priority.tpl' -%}
+{% block in_prompt -%}
+In[{{cell.prompt_number if cell.prompt_number else ' '}}]:
+
+.. code:: python
+
+{% endblock in_prompt %}
+
+{% block output_prompt %}{% if cell.haspyout -%}
+Out[{{cell.prompt_number}}]:{% endif %}{% endblock output_prompt %}
+
+{% block input %}{{ cell.input | indent}}
+
+{% endblock input %}
+
+{% block pyerr %}::
+{{ super() }}
+{% endblock pyerr %}
+
+{% block traceback_line %}
+{{ line |indent| rm_ansi }}{% endblock traceback_line %}
+
+{% block pyout %}
+{% block data_priority scoped %}{{ super()}}{% endblock %}
+{% endblock pyout %}
+
+{% block stream %}
+.. parsed-literal::
+
+{{ output.text| indent }}
+{% endblock stream %}
+
+
+
+
+{% block data_svg %}.. image:: {{output.key_svg}}
+
+{% endblock data_svg %}
+
+{% block data_png %}.. image:: {{output.key_png}}
+
+{% endblock data_png %}
+
+{% block data_jpg %}..jpg image:: {{output.key_jpg}}
+
+{% endblock data_jpg %}
+
+
+
+{% block data_latex %}.. math::
+
+{{output.latex| indent}}
+
+{% endblock data_latex %}
+
+{% block data_text scoped %}.. parsed-literal::
+
+{{output.text | indent}}
+
+{% endblock data_text %}
+
+{% block markdowncell scoped %}{{ cell.source | markdown2rst }}
+{% endblock markdowncell %}
+
+{% block headingcell scoped %}
+{%- set len = cell.source|length -%}
+{{ cell.source}}
+{% if cell.level == 1 %}
+{{- '=' * len }}
+{%- elif cell.level == 2 %}
+{{- '-' * len }}
+{%- elif cell.level == 3 %}
+{{- '~' * len }}
+{%- elif cell.level == 4 %}
+{{- '.' * len }}
+{%- elif cell.level == 5 %}
+{{- '\\' * len }}
+{%- elif cell.level == 6 %}
+{{- '`' * len }}
+{% endif %}
+
+{% endblock headingcell %}
+
+{% block rawcell scoped %}{{ cell.source  }}
+{% endblock rawcell %}
+
+{% block unknowncell scoped %}
+unknown type  {{cell.type}}
+{% endblock unknowncell %}

IPython/nbconvert/templates/skeleton/Makefile

@@ -0,0 +1,23 b''
+
+
+all: tex/null.tplx tex/display_priority.tplx
+
+# convert jinja syntax to tex
+# cf http://flask.pocoo.org/snippets/55/
+tex/%.tplx: %.tpl
+	@echo 'generating tex equivalent of $^: $@'
+	@echo '((= autogenerated file do not edit =))' > $@
+	@sed \
+		-e 's/{%/((*/g' \
+		-e 's/%}/*))/g' \
+		-e 's/{{/(((/g' \
+		-e 's/}}/)))/g' \
+		-e 's/{#/((=/g' \
+		-e 's/#}/=))/g' \
+		-e "s/tpl'/tplx'/g" \
+		$^ >> $@
+
+
+clean:
+	@echo "cleaning generated tplx files..."
+	@rm tex/*

IPython/nbconvert/templates/skeleton/README.md

@@ -0,0 +1,6 b''
+## Template skeleton
+
+This contain skeleton template that you probably don't want
+to inherit directly.
+
+do not moify the content of the 'tex' folder which is generated by running 'make' in this folder.

IPython/nbconvert/templates/skeleton/display_priority.tpl

@@ -0,0 +1,38 b''
+{%- extends 'null.tpl' -%}
+
+{#display data priority#}
+
+
+{%- block data_priority scoped -%}
+    {%- for type in output | filter_data_type -%}
+        {%- if type in ['pdf']%}
+            {%- block data_pdf -%}
+            {%- endblock -%}
+        {%- endif -%}
+        {%- if type in ['svg']%}
+            {%- block data_svg -%}
+            {%- endblock -%}
+        {%- endif -%}
+        {%- if type in ['png']%}
+            {%- block data_png -%}
+            {%- endblock -%}
+        {%- endif -%}
+        {%- if type in ['html']%}
+            {%- block data_html -%}
+            {%- endblock -%}
+        {%- endif -%}
+        {%- if type in ['jpeg']%}
+            {%- block data_jpg -%}
+            {%- endblock -%}
+        {%- endif -%}
+        {%- if type in ['text']%}
+            {%- block data_text -%}
+            {%- endblock -%}
+        {%- endif -%}
+
+        {%- if type in ['latex']%}
+            {%- block data_latex -%}
+            {%- endblock -%}
+        {%- endif -%}
+    {%- endfor -%}
+{%- endblock data_priority -%}

IPython/nbconvert/templates/skeleton/null.tpl

@@ -0,0 +1,91 b''
+{#
+
+DO NOT USE THIS AS A BASE WORK,
+IF YOU ARE COPY AND PASTING THIS FILE
+YOU ARE PROBABLY DOING THINGS WRONG.
+
+Null template, Does nothing except defining a basic structure
+To layout the different blocks of a notebook.
+
+Subtemplates can override blocks to define their custom representation.
+
+If one of the block you do overwrite is not a leave block, consider
+calling super.
+
+{%- block nonLeaveBlock -%}
+    #add stuff at beginning
+    {{ super() }}
+    #add stuff at end
+{%- endblock nonLeaveBlock -%}
+
+consider calling super even if it is a leave block, we might insert more blocks later.
+
+#}
+{%- block header -%}
+{%- endblock header -%}
+{%- block body -%}
+{%- for worksheet in nb.worksheets -%}
+    {%- for cell in worksheet.cells -%}
+        {%- block any_cell scoped -%}
+            {%- if cell.cell_type in ['code'] -%}
+                {%- block codecell scoped -%}
+                    {%- block input_group -%}
+                        {%- block in_prompt -%}{%- endblock in_prompt -%}
+                        {%- block input -%}{%- endblock input -%}
+                    {%- endblock input_group -%}
+                    {%- if cell.outputs -%}
+                    {%- block output_group -%}
+                        {%- block output_prompt -%}{%- endblock output_prompt -%}
+                        {%- block outputs scoped -%}
+                            {%- for output in cell.outputs -%}
+                                {%- block output scoped -%}
+                                    {%- if output.output_type in ['pyout'] -%}
+                                        {%- block pyout scoped -%}{%- endblock pyout -%}
+                                    {%- elif output.output_type in ['stream'] -%}
+                                        {%- block stream scoped -%}
+                                            {%- if output.stream in ['stdout'] -%}
+                                                {%- block stream_stdout scoped -%}
+                                                {%- endblock stream_stdout -%}
+                                            {%- elif output.stream in ['stderr'] -%}
+                                                {%- block stream_stderr scoped -%}
+                                                {%- endblock stream_stderr -%}
+                                            {%- endif -%}
+                                        {%- endblock stream -%}
+                                    {%- elif output.output_type in ['display_data'] -%}
+                                        {%- block display_data scoped -%}
+                                            {%- block data_priority scoped -%}
+                                            {%- endblock data_priority -%}
+                                        {%- endblock display_data -%}
+                                    {%- elif output.output_type in ['pyerr'] -%}
+                                        {%- block pyerr scoped -%}
+                                        {%- for line in output.traceback -%}
+                                            {%- block traceback_line scoped -%}{%- endblock traceback_line -%}
+                                        {%- endfor -%}
+                                        {%- endblock pyerr -%}
+                                    {%- endif -%}
+                                {%- endblock output -%}
+                            {%- endfor -%}
+                        {%- endblock outputs -%}
+                    {%- endblock output_group -%}
+                    {%- endif -%}
+                {%- endblock codecell -%}
+            {%- elif cell.cell_type in ['markdown'] -%}
+                {%- block markdowncell scoped-%}
+                {%- endblock markdowncell -%}
+            {%- elif cell.cell_type in ['heading'] -%}
+                {%- block headingcell scoped-%}
+                {%- endblock headingcell -%}
+            {%- elif cell.cell_type in ['raw'] -%}
+                {%- block rawcell scoped-%}
+                {%- endblock rawcell -%}
+            {%- else -%}
+                {%- block unknowncell scoped-%}
+                {%- endblock unknowncell -%}
+            {%- endif -%}
+        {%- endblock any_cell -%}
+    {%- endfor -%}
+{%- endfor -%}
+{%- endblock body -%}
+
+{%- block footer -%}
+{%- endblock footer -%}

IPython/nbconvert/templates/slides.tpl

@@ -0,0 +1,17 b''
+{%- extends 'subslides.tpl' -%}
+
+
+
+{%- block any_cell scoped -%}
+{%- if cell.metadata.slide_type in ['slide'] -%}  
+    <section>
+    <section>
+{%- endif -%}
+    
+{{ super() }}
+    
+{%- if cell.metadata.slide_helper in ['slide_end'] -%}
+    </section>
+    </section>
+{%- endif -%}
+{%- endblock any_cell -%}

IPython/nbconvert/templates/subslides.tpl

@@ -0,0 +1,15 b''
+{%- extends 'align_reveal_cells.tpl' -%}
+
+
+
+{%- block any_cell scoped -%}
+{%- if cell.metadata.slide_type in ['subslide'] -%}  
+    <section>
+{%- endif -%}
+    
+{{ super() }}
+    
+{%- if cell.metadata.slide_helper in ['subslide_end'] -%}
+    </section>
+{%- endif -%}
+{%- endblock any_cell -%}

IPython/nbconvert/transformers/__init__.py

@@ -0,0 +1,9 b''
+# Class base Transformers
+from .activatable import ActivatableTransformer
+from .base import ConfigurableTransformer
+from .extractfigure import ExtractFigureTransformer
+from .latex import LatexTransformer
+from .sphinx import SphinxTransformer
+
+# decorated function Transformers
+from .coalescestreams import coalesce_streams

IPython/nbconvert/transformers/activatable.py

@@ -0,0 +1,53 b''
+"""
+Contains base transformer with an enable/disable flag.
+"""
+#-----------------------------------------------------------------------------
+# 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 ConfigurableTransformer
+from IPython.utils.traitlets import (Bool)
+
+#-----------------------------------------------------------------------------
+# Classes and Functions
+#-----------------------------------------------------------------------------
+
+class ActivatableTransformer(ConfigurableTransformer):
+    """ConfigurableTransformer that has an enabled flag
+
+    Inherit from this if you just want to have a transformer which is
+    disable by default and can be enabled via the config by
+        'c.YourTransformerName.enabled = True'
+    """
+
+    enabled = Bool(False, config=True)
+
+    def __call__(self, nb, resources):
+        """
+        Transformation to apply on each notebook.
+        
+        You should return modified nb, resources.
+        If you wish to apply your transform on each cell, you might want to 
+        overwrite cell_transform method instead.
+        
+        Parameters
+        ----------
+        nb : NotebookNode
+            Notebook being converted
+        resources : dictionary
+            Additional resources used in the conversion process.  Allows
+            transformers to pass variables into the Jinja engine.
+        """
+        
+        if not self.enabled :
+            return nb, resources
+        else :
+            return super(ActivatableTransformer, self).__call__(nb, resources)

IPython/nbconvert/transformers/base.py

@@ -0,0 +1,99 b''
+"""
+Module that re-groups transformer that would be applied to ipynb files
+before going through the templating machinery.
+
+It exposes a convenient class to inherit from to access configurability.
+"""
+#-----------------------------------------------------------------------------
+# 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 ..utils.config import GlobalConfigurable
+
+#-----------------------------------------------------------------------------
+# Classes and Functions
+#-----------------------------------------------------------------------------
+
+class ConfigurableTransformer(GlobalConfigurable):
+    """ A configurable transformer
+
+    Inherit from this class if you wish to have configurability for your
+    transformer.
+
+    Any configurable traitlets this class exposed will be configurable in profiles
+    using c.SubClassName.atribute=value
+
+    you can overwrite cell_transform to apply a transformation independently on each cell
+    or __call__ if you prefer your own logic. See corresponding docstring for informations.
+    """
+    
+    def __init__(self, config=None, **kw):
+        """
+        Public constructor
+        
+        Parameters
+        ----------
+        config : Config
+            Configuration file structure
+        **kw : misc
+            Additional arguments
+        """
+        
+        super(ConfigurableTransformer, self).__init__(config=config, **kw)
+
+       
+    def __call__(self, nb, resources):
+        return self.call(nb,resources)
+
+    def call(self, nb, resources):
+        """
+        Transformation to apply on each notebook.
+        
+        You should return modified nb, resources.
+        If you wish to apply your transform on each cell, you might want to 
+        overwrite cell_transform method instead.
+        
+        Parameters
+        ----------
+        nb : NotebookNode
+            Notebook being converted
+        resources : dictionary
+            Additional resources used in the conversion process.  Allows
+            transformers to pass variables into the Jinja engine.
+        """
+        try :
+            for worksheet in nb.worksheets :
+                for index, cell in enumerate(worksheet.cells):
+                    worksheet.cells[index], resources = self.cell_transform(cell, resources, index)
+            return nb, resources
+        except NotImplementedError:
+            raise NotImplementedError('should be implemented by subclass')
+
+
+    def cell_transform(self, cell, resources, index):
+        """
+        Overwrite if you want to apply a transformation on each cell.  You 
+        should return modified cell and resource dictionary.
+        
+        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.
+        index : int
+            Index of the cell being processed
+        """
+
+        raise NotImplementedError('should be implemented by subclass')
+        return cell, resources
+

IPython/nbconvert/transformers/coalescestreams.py

@@ -0,0 +1,75 b''
+"""Module that allows latex output notebooks to be conditioned before
+they are converted.  Exposes a decorator (@cell_preprocessor) in
+addition to the coalesce_streams pre-proccessor.
+"""
+#-----------------------------------------------------------------------------
+# 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.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Functions
+#-----------------------------------------------------------------------------
+
+def cell_preprocessor(function):
+    """
+    Wrap a function to be executed on all cells of a notebook
+    
+    Wrapped 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.
+    index : int
+        Index of the cell being processed
+    """
+    
+    def wrappedfunc(nb, resources):
+        for worksheet in nb.worksheets :
+            for index, cell in enumerate(worksheet.cells):
+                worksheet.cells[index], resources = function(cell, resources, index)
+        return nb, resources
+    return wrappedfunc
+
+
+@cell_preprocessor
+def coalesce_streams(cell, resources, index):
+    """
+    Merge consecutive sequences of stream output into single stream
+    to prevent extra newlines inserted at flush calls
+    
+    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.
+    index : int
+        Index of the cell being processed
+    """
+    
+    outputs = cell.get('outputs', [])
+    if not outputs:
+        return cell, resources
+    
+    last = outputs[0]
+    new_outputs = [last]
+    
+    for output in outputs[1:]:
+        if (output.output_type == 'stream' and
+            last.output_type == 'stream' and
+            last.stream == output.stream
+        ):
+            last.text += output.text
+        else:
+            new_outputs.append(output)
+
+    cell.outputs = new_outputs
+    return cell, resources
+

IPython/nbconvert/transformers/csshtmlheader.py

@@ -0,0 +1,105 b''
+"""Module that pre-processes the notebook for export to 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
+#-----------------------------------------------------------------------------
+
+import os
+import io
+
+from pygments.formatters import HtmlFormatter
+        
+from IPython.utils import path
+
+from .activatable import ActivatableTransformer
+        
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+class CSSHtmlHeaderTransformer(ActivatableTransformer):
+    """
+    Transformer used to pre-process notebook for HTML output.  Adds IPython notebook
+    front-end CSS and Pygments CSS to HTML output.
+    """
+
+    header = []
+
+    def __init__(self, config=None, **kw):
+        """
+        Public constructor
+        
+        Parameters
+        ----------
+        config : Config
+            Configuration file structure
+        **kw : misc
+            Additional arguments
+        """
+        
+        super(CSSHtmlHeaderTransformer, self).__init__(config=config, **kw)
+
+        if self.enabled :
+            self._regen_header()
+
+
+    def __call__(self, nb, resources):
+        """Fetch and add CSS to the resource dictionary
+
+        Fetch CSS from IPython and Pygments to add at the beginning
+        of the html files.  Add this css in resources in the 
+        "inlining.css" key
+        
+        Parameters
+        ----------
+        nb : NotebookNode
+            Notebook being converted
+        resources : dictionary
+            Additional resources used in the conversion process.  Allows
+            transformers to pass variables into the Jinja engine.
+        """
+        
+        resources['inlining'] = {}
+        resources['inlining']['css'] = self.header
+        
+        return nb, resources
+
+
+    def _regen_header(self):
+        """ 
+        Fills self.header with lines of CSS extracted from IPython 
+        and Pygments.
+        """
+        
+        #Clear existing header.
+        header = []
+        
+        #Construct path to IPy CSS
+        sheet_filename = os.path.join(path.get_ipython_package_dir(), 
+            'html', 'static', 'style', 'style.min.css')
+        
+        #Load style CSS file.
+        try:
+            with io.open(sheet_filename, encoding='utf-8') as file:
+                file_text = file.read()
+                header.append(file_text)
+        except IOError:
+            
+            # New version of IPython with style.min.css, pass
+            pass
+
+        #Add pygments CSS
+        pygments_css = HtmlFormatter().get_style_defs('.highlight')
+        header.append(pygments_css)
+
+        #Set header        
+        self.header = header
+

IPython/nbconvert/transformers/extractfigure.py

@@ -0,0 +1,143 b''
+"""Module containing a transformer that extracts all of the figures from the
+notebook file.  The extracted figures 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 itertools
+
+from IPython.utils.traitlets import Dict, Unicode
+from .activatable import ActivatableTransformer
+
+#-----------------------------------------------------------------------------
+# Constants
+#-----------------------------------------------------------------------------
+
+FIGURES_KEY = "figures"
+BINARY_KEY = "binary"
+TEXT_KEY = "text"
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class ExtractFigureTransformer(ActivatableTransformer):
+    """
+    Extracts all of the figures from the notebook file.  The extracted 
+    figures are returned in the 'resources' dictionary.
+    """
+
+    extra_extension_map =  Dict({},
+        config=True,
+        help="""Extra map to override extension based on type.
+        Useful for latex where SVG will be converted to PDF before inclusion
+        """)
+    
+    key_format_map =  Dict({}, config=True,)
+    figure_name_format_map =  Dict({}, config=True)
+
+    #TODO: Change this to .format {} syntax
+    default_key_template = Unicode('_fig_{index:02d}.{ext}', config=True)
+
+    def __init__(self, config=None, **kw):
+        """
+        Public constructor
+        
+        Parameters
+        ----------
+        config : Config
+            Configuration file structure
+        **kw : misc
+            Additional arguments
+        """
+
+        super(ExtractFigureTransformer, self).__init__(config=config, **kw)
+
+        # A unique index for association with extracted figures
+        self.index_generator = itertools.count(1)
+
+    def cell_transform(self, cell, resources, 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.
+        index : int
+            Index of the cell being processed (see base.py)
+        """
+        
+        if resources.get(FIGURES_KEY, None) is None :
+            resources[FIGURES_KEY] = {TEXT_KEY:{},BINARY_KEY:{}}
+            
+        for out in cell.get('outputs', []):
+            for out_type in self.display_data_priority:
+                
+                if out.hasattr(out_type):
+                    figname, key, data, binary = self._new_figure(out[out_type], out_type)
+                    out['key_'+out_type] = figname
+                    
+                    if binary :
+                        resources[FIGURES_KEY][BINARY_KEY][key] = data
+                    else :
+                        resources[FIGURES_KEY][TEXT_KEY][key] = data
+                        
+                    index += 1
+        return cell, resources
+
+
+    def _get_override_extension(self, extension):
+        """Gets the overriden extension if it exists, else returns extension. 
+
+        Parameters
+        ----------
+        extension : str
+            File extension.
+        """
+        
+        if extension in self.extra_extension_map :
+            return self.extra_extension_map[extension]
+    
+        return extension
+
+
+    def _new_figure(self, data, format):
+        """Create a new figure file in the given format.
+
+        Parameters
+        ----------
+        data : str
+            Cell data (from Notebook node cell)
+        format : str
+            Figure format
+        index : int
+            Index of the figure being extracted
+        """
+        
+        figure_name_template = self.figure_name_format_map.get(format, self.default_key_template)
+        key_template = self.key_format_map.get(format, self.default_key_template)
+        
+        #TODO: option to pass the hash as data?
+        index = next(self.index_generator)
+        figure_name = figure_name_template.format(index=index, ext=self._get_override_extension(format))
+        key = key_template.format(index=index, ext=self._get_override_extension(format))
+
+        #Binary files are base64-encoded, SVG is already XML
+        binary = False
+        if format in ('png', 'jpg', 'pdf'):
+            data = data.decode('base64')
+            binary = True
+
+        return figure_name, key, data, binary

IPython/nbconvert/transformers/latex.py

@@ -0,0 +1,53 b''
+"""Module that allows latex output notebooks to be conditioned before
+they are converted.
+"""
+#-----------------------------------------------------------------------------
+# 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
+
+# Our own imports
+# Needed to override transformer
+from .activatable import (ActivatableTransformer)
+from IPython.nbconvert import filters
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+
+class LatexTransformer(ActivatableTransformer):
+    """
+    Converter for latex destined documents.
+    """
+
+    def cell_transform(self, cell, resources, 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.
+        index : int
+            Modified index of the cell being processed (see base.py)
+        """
+        
+        #If the cell is a markdown cell, preprocess the ampersands used to
+        #remove the space between them and their contents.  Latex will complain
+        #if spaces exist between the ampersands and the math content.  
+        #See filters.latex.rm_math_space for more information.
+        if hasattr(cell, "source") and cell.cell_type == "markdown":
+            cell.source = filters.rm_math_space(cell.source)
+        return cell, resources

IPython/nbconvert/transformers/revealhelp.py

@@ -0,0 +1,52 b''
+"""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 ConfigurableTransformer
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+class RevealHelpTransformer(ConfigurableTransformer):
+
+    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 i, 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[i - 1].metadata.slide_helper = 'slide_end'
+                if cell.metadata.slide_type in ['subslide']:
+                    worksheet.cells[i - 1].metadata.slide_helper = 'subslide_end'
+                    
+        return nb, resources
+    
  No newline at end of file

IPython/nbconvert/transformers/sphinx.py

@@ -0,0 +1,261 b''
+"""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
+# Used to find Sphinx package location
+import sphinx
+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 .activatable import (ActivatableTransformer) #TODO
+
+from IPython.nbconvert.utils import console  
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+class SphinxTransformer(ActivatableTransformer):
+    """
+    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.
+        """
+         
+        # 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 "_draft" in nb.metadata:
+            nb.metadata._draft = {}
+            
+        if not "sphinx" in resources:
+            resources["sphinx"] = {}
+
+        if self.interactive:
+            
+            # Prompt the user for additional meta data that doesn't exist currently
+            # but would be usefull for Sphinx.
+            nb.metadata._draft["author"] = self._prompt_author()
+            nb.metadata._draft["version"] = self._prompt_version()
+            nb.metadata._draft["release"] = self._prompt_release()
+            nb.metadata._draft["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.
+            nb.metadata._draft["author"] = self.author
+            nb.metadata._draft["version"] = self.version
+            nb.metadata._draft["release"] = self.release
+            
+            # Use todays date if none is provided.
+            if len(self.publish_date.strip()) == 0:
+                nb.metadata._draft["date"] = date.today().strftime("%B %-d, %Y")
+            else:
+                nb.metadata._draft["date"] = self.publish_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.abspath(sphinx.__file__ + "/../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):
+            nb.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):
+        """
+        Prompt the user to enter a date
+        """
+        
+        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/utils/config.py

@@ -0,0 +1,37 b''
+"""Global configuration class."""
+#-----------------------------------------------------------------------------
+# 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 List
+from IPython.config.configurable import Configurable
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+           
+class GlobalConfigurable(Configurable):
+    """Global configurable class for shared config
+
+    Usefull for display data priority that might be use by many trasnformers
+    """
+
+    display_data_priority = List(['html', 'pdf', 'svg', 'latex', 'png', 'jpg', 'jpeg' , 'text'],
+            config=True,
+              help= """
+                    An ordered list of prefered output type, the first
+                    encounterd will usually be used when converting discarding
+                    the others.
+                    """
+            )
+
+    def __init__(self, config=None, **kw):
+        super(GlobalConfigurable, self).__init__( config=config, **kw)

IPython/nbconvert/utils/console.py

@@ -0,0 +1,120 b''
+"""Utility functions for interacting with the console"""
+#-----------------------------------------------------------------------------
+# 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
+#-----------------------------------------------------------------------------
+
+# Used to determine python version
+import sys
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+            
+def input(prompt_text):
+    """
+    Prompt the user for input.
+    
+    The input command will change depending on the version of python
+    installed.  To maintain support for 2 and earlier, we must use
+    raw_input in that case.  Else use input.
+    
+    Parameters
+    ----------
+    prompt_text : str
+        Prompt to display to the user.
+    """
+    
+    # Try to get the python version.  This command is only available in
+    # python 2 and later, so it's important that we catch the exception
+    # if the command isn't found.
+    try:
+        majorversion = sys.version_info[0]
+    except AttributeError:
+        majorversion = 1
+        
+    # Use the correct function to prompt the user for input depending on 
+    # what python version the code is running in.
+    if majorversion >= 3:
+        return input(prompt_text) 
+    else:
+        return raw_input(prompt_text).decode(sys.stdin.encoding)
+
+    
+def prompt_boolean(prompt, default=False):
+    """
+    Prompt the user for a boolean response.
+    
+    Parameters
+    ----------
+    prompt : str
+        prompt to display to the user
+    default : bool, optional
+        response to return if none is given by the user
+    """
+    
+    response = input(prompt)
+    response = response.strip().lower()
+    
+    #Catch 1, true, yes as True
+    if len(response) > 0 and (response == "1" or response[0] == "t" or response[0] == "y"):
+        return True
+    
+    #Catch 0, false, no as False
+    elif len(response) > 0 and (response == "0" or response[0] == "f" or response[0] == "n"):
+        return False
+        
+    else:
+        return default
+
+
+def prompt_dictionary(choices, default_style=1, menu_comments={}):
+    """
+    Prompt the user to chose one of many selections from a menu.
+    
+    Parameters
+    ----------
+    choices : dictionary
+        Keys - choice numbers (int)
+        Values - choice value (str), this is what the function will return
+    default_style : int, optional
+        Choice to select if the user doesn't respond
+    menu_comments : dictionary, optional
+        Additional comments to append to the menu as it is displayed
+        in the console.
+        Keys - choice numbers (int)
+        Values - comment (str), what will be appended to the 
+        corresponding choice
+    """
+            
+    # Build the menu that will be displayed to the user with
+    # all of the options available. 
+    prompt = ""
+    for key, value in choices.iteritems():
+        prompt += "%d %s " % (key, value)
+        if key in menu_comments:
+            prompt += menu_comments[key]
+        prompt += "\n"
+    
+    # Continue to ask the user for a style until an appropriate
+    # one is specified.
+    response = -1
+    while (not response in choices):
+        try:
+            text_response = input(prompt)
+            
+            # Use default option if no input.
+            if len(text_response.strip()) == 0:
+                response = default_style
+            else:
+                response = int(text_response)
+        except ValueError:
+            print("Error: Value is not an available option.  0 selects the default.\n")
+    return choices[response]

IPython/nbconvert/utils/exceptions.py

@@ -0,0 +1,17 b''
+"""NbConvert specific exceptions"""
+#-----------------------------------------------------------------------------
+# 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.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+class ConversionException(Exception):
+    """An exception raised by the conversion process."""
+
+    pass
  No newline at end of file

IPython/nbconvert/utils/lexers.py

@@ -0,0 +1,46 b''
+"""A custom pygments lexer for IPython code cells.
+
+Informs The pygments highlighting library of the quirks of IPython's superset
+of Python -- magic commands, !shell commands, etc.
+"""
+#-----------------------------------------------------------------------------
+# 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
+#-----------------------------------------------------------------------------
+
+# Third-party imports
+from pygments.lexers import PythonLexer, BashLexer
+from pygments.lexer import bygroups, using
+from pygments.token import Keyword, Operator, Text
+
+#-----------------------------------------------------------------------------
+# Class declarations
+#-----------------------------------------------------------------------------
+
+class IPythonLexer(PythonLexer):
+    """
+    Pygments Lexer for use with IPython code.  Inherits from 
+    PythonLexer and adds information about IPython specific
+    keywords (i.e. magic commands, shell commands, etc.)
+    """
+    
+    #Basic properties
+    name = 'IPython'
+    aliases = ['ip', 'ipython']
+    filenames = ['*.ipy']
+    
+    #Highlighting information
+    tokens = PythonLexer.tokens.copy()
+    tokens['root'] = [
+        (r'(\%+)(\w+)\s+(\.*)(\n)', bygroups(Operator, Keyword,
+                                             using(BashLexer), Text)),
+        (r'(\%+)(\w+)\b', bygroups(Operator, Keyword)),
+        (r'^(!)(.+)(\n)', bygroups(Operator, using(BashLexer), Text)),
+        ] + tokens['root']

IPython/terminal/ipapp.py

@@ -1,395 +1,400 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 The :class:`~IPython.core.application.Application` object for the command
 line :command:`ipython` program.
 
 Authors
 -------
 
 * Brian Granger
 * Fernando Perez
 * Min Ragan-Kelley
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from __future__ import absolute_import
 
 import logging
 import os
 import sys
 
 from IPython.config.loader import (
     Config, PyFileConfigLoader, ConfigFileNotFound
 )
 from IPython.config.application import boolean_flag, catch_config_error
 from IPython.core import release
 from IPython.core import usage
 from IPython.core.completer import IPCompleter
 from IPython.core.crashhandler import CrashHandler
 from IPython.core.formatters import PlainTextFormatter
 from IPython.core.history import HistoryManager
 from IPython.core.prompts import PromptManager
 from IPython.core.application import (
     ProfileDir, BaseIPythonApplication, base_flags, base_aliases
 )
 from IPython.core.magics import ScriptMagics
 from IPython.core.shellapp import (
     InteractiveShellApp, shell_flags, shell_aliases
 )
 from IPython.terminal.interactiveshell import TerminalInteractiveShell
 from IPython.utils import warn
 from IPython.utils.path import get_ipython_dir, check_for_old_config
 from IPython.utils.traitlets import (
     Bool, List, Dict, CaselessStrEnum
 )
 
 #-----------------------------------------------------------------------------
 # Globals, utilities and helpers
 #-----------------------------------------------------------------------------
 
 #: The default config file name for this application.
 default_config_file_name = u'ipython_config.py'
 
 _examples = """
 ipython --pylab            # start in pylab mode
 ipython --pylab=qt         # start in pylab mode with the qt4 backend
 ipython --log-level=DEBUG  # set logging to DEBUG
 ipython --profile=foo      # start with profile foo
 
 ipython qtconsole          # start the qtconsole GUI application
 ipython help qtconsole     # show the help for the qtconsole subcmd
 
 ipython console            # start the terminal-based console application
 ipython help console       # show the help for the console subcmd
 
 ipython notebook           # start the IPython notebook
 ipython help notebook      # show the help for the notebook subcmd
 
 ipython profile create foo # create profile foo w/ default config files
 ipython help profile       # show the help for the profile subcmd
 
 ipython locate             # print the path to the IPython directory
 ipython locate profile foo # print the path to the directory for profile `foo`
+
+ipython nbconvert           # convert notebooks to/from other formats
 """
 
 #-----------------------------------------------------------------------------
 # Crash handler for this application
 #-----------------------------------------------------------------------------
 
 class IPAppCrashHandler(CrashHandler):
     """sys.excepthook for IPython itself, leaves a detailed report on disk."""
 
     def __init__(self, app):
         contact_name = release.author
         contact_email = release.author_email
         bug_tracker = 'https://github.com/ipython/ipython/issues'
         super(IPAppCrashHandler,self).__init__(
             app, contact_name, contact_email, bug_tracker
         )
 
     def make_report(self,traceback):
         """Return a string containing a crash report."""
 
         sec_sep = self.section_sep
         # Start with parent report
         report = [super(IPAppCrashHandler, self).make_report(traceback)]
         # Add interactive-specific info we may have
         rpt_add = report.append
         try:
             rpt_add(sec_sep+"History of session input:")
             for line in self.app.shell.user_ns['_ih']:
                 rpt_add(line)
             rpt_add('\n*** Last line of input (may not be in above history):\n')
             rpt_add(self.app.shell._last_input_line+'\n')
         except:
             pass
 
         return ''.join(report)
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 flags = dict(base_flags)
 flags.update(shell_flags)
 frontend_flags = {}
 addflag = lambda *args: frontend_flags.update(boolean_flag(*args))
 addflag('autoedit-syntax', 'TerminalInteractiveShell.autoedit_syntax',
         'Turn on auto editing of files with syntax errors.',
         'Turn off auto editing of files with syntax errors.'
 )
 addflag('banner', 'TerminalIPythonApp.display_banner',
         "Display a banner upon starting IPython.",
         "Don't display a banner upon starting IPython."
 )
 addflag('confirm-exit', 'TerminalInteractiveShell.confirm_exit',
     """Set to confirm when you try to exit IPython with an EOF (Control-D
     in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
     you can force a direct exit without any confirmation.""",
     "Don't prompt the user when exiting."
 )
 addflag('term-title', 'TerminalInteractiveShell.term_title',
     "Enable auto setting the terminal title.",
     "Disable auto setting the terminal title."
 )
 classic_config = Config()
 classic_config.InteractiveShell.cache_size = 0
 classic_config.PlainTextFormatter.pprint = False
 classic_config.PromptManager.in_template = '>>> '
 classic_config.PromptManager.in2_template = '... '
 classic_config.PromptManager.out_template = ''
 classic_config.InteractiveShell.separate_in = ''
 classic_config.InteractiveShell.separate_out = ''
 classic_config.InteractiveShell.separate_out2 = ''
 classic_config.InteractiveShell.colors = 'NoColor'
 classic_config.InteractiveShell.xmode = 'Plain'
 
 frontend_flags['classic']=(
     classic_config,
     "Gives IPython a similar feel to the classic Python prompt."
 )
 # # log doesn't make so much sense this way anymore
 # paa('--log','-l',
 #     action='store_true', dest='InteractiveShell.logstart',
 #     help="Start logging to the default log file (./ipython_log.py).")
 #
 # # quick is harder to implement
 frontend_flags['quick']=(
     {'TerminalIPythonApp' : {'quick' : True}},
     "Enable quick startup with no config files."
 )
 
 frontend_flags['i'] = (
     {'TerminalIPythonApp' : {'force_interact' : True}},
     """If running code from the command line, become interactive afterwards.
     Note: can also be given simply as '-i.'"""
 )
 flags.update(frontend_flags)
 
 aliases = dict(base_aliases)
 aliases.update(shell_aliases)
 
 #-----------------------------------------------------------------------------
 # Main classes and functions
 #-----------------------------------------------------------------------------
 
 
 class LocateIPythonApp(BaseIPythonApplication):
     description = """print the path to the IPython dir"""
     subcommands = Dict(dict(
         profile=('IPython.core.profileapp.ProfileLocate',
             "print the path to an IPython profile directory",
         ),
     ))
     def start(self):
         if self.subapp is not None:
             return self.subapp.start()
         else:
             print self.ipython_dir
 
 
 class TerminalIPythonApp(BaseIPythonApplication, InteractiveShellApp):
     name = u'ipython'
     description = usage.cl_usage
     default_config_file_name = default_config_file_name
     crash_handler_class = IPAppCrashHandler
     examples = _examples
 
     flags = Dict(flags)
     aliases = Dict(aliases)
     classes = List()
     def _classes_default(self):
         """This has to be in a method, for TerminalIPythonApp to be available."""
         return [
             InteractiveShellApp, # ShellApp comes before TerminalApp, because
             self.__class__,      # it will also affect subclasses (e.g. QtConsole)
             TerminalInteractiveShell,
             PromptManager,
             HistoryManager,
             ProfileDir,
             PlainTextFormatter,
             IPCompleter,
             ScriptMagics,
         ]
 
     subcommands = Dict(dict(
         qtconsole=('IPython.qt.console.qtconsoleapp.IPythonQtConsoleApp',
             """Launch the IPython Qt Console."""
         ),
         notebook=('IPython.html.notebookapp.NotebookApp',
             """Launch the IPython HTML Notebook Server."""
         ),
         profile = ("IPython.core.profileapp.ProfileApp",
             "Create and manage IPython profiles."
         ),
         kernel = ("IPython.kernel.zmq.kernelapp.IPKernelApp",
             "Start a kernel without an attached frontend."
         ),
         console=('IPython.terminal.console.app.ZMQTerminalIPythonApp',
             """Launch the IPython terminal-based Console."""
         ),
         locate=('IPython.terminal.ipapp.LocateIPythonApp',
             LocateIPythonApp.description
         ),
         history=('IPython.core.historyapp.HistoryApp',
             "Manage the IPython history database."
         ),
+        nbconvert=('IPython.nbconvert.nbconvertapp.NbConvertApp',
+            "Convert notebooks to/from other formats."
+        ),
     ))
 
     # *do* autocreate requested profile, but don't create the config file.
     auto_create=Bool(True)
     # configurables
     ignore_old_config=Bool(False, config=True,
         help="Suppress warning messages about legacy config files"
     )
     quick = Bool(False, config=True,
         help="""Start IPython quickly by skipping the loading of config files."""
     )
     def _quick_changed(self, name, old, new):
         if new:
             self.load_config_file = lambda *a, **kw: None
             self.ignore_old_config=True
 
     display_banner = Bool(True, config=True,
         help="Whether to display a banner upon starting IPython."
     )
 
     # if there is code of files to run from the cmd line, don't interact
     # unless the --i flag (App.force_interact) is true.
     force_interact = Bool(False, config=True,
         help="""If a command or file is given via the command-line,
         e.g. 'ipython foo.py"""
     )
     def _force_interact_changed(self, name, old, new):
         if new:
             self.interact = True
 
     def _file_to_run_changed(self, name, old, new):
         if new:
             self.something_to_run = True
         if new and not self.force_interact:
                 self.interact = False
     _code_to_run_changed = _file_to_run_changed
     _module_to_run_changed = _file_to_run_changed
 
     # internal, not-configurable
     interact=Bool(True)
     something_to_run=Bool(False)
 
     def parse_command_line(self, argv=None):
         """override to allow old '-pylab' flag with deprecation warning"""
 
         argv = sys.argv[1:] if argv is None else argv
 
         if '-pylab' in argv:
             # deprecated `-pylab` given,
             # warn and transform into current syntax
             argv = argv[:] # copy, don't clobber
             idx = argv.index('-pylab')
             warn.warn("`-pylab` flag has been deprecated.\n"
             "    Use `--pylab` instead, or `--pylab=foo` to specify a backend.")
             sub = '--pylab'
             if len(argv) > idx+1:
                 # check for gui arg, as in '-pylab qt'
                 gui = argv[idx+1]
                 if gui in ('wx', 'qt', 'qt4', 'gtk', 'auto'):
                     sub = '--pylab='+gui
                     argv.pop(idx+1)
             argv[idx] = sub
 
         return super(TerminalIPythonApp, self).parse_command_line(argv)
     
     @catch_config_error
     def initialize(self, argv=None):
         """Do actions after construct, but before starting the app."""
         super(TerminalIPythonApp, self).initialize(argv)
         if self.subapp is not None:
             # don't bother initializing further, starting subapp
             return
         if not self.ignore_old_config:
             check_for_old_config(self.ipython_dir)
         # print self.extra_args
         if self.extra_args and not self.something_to_run:
             self.file_to_run = self.extra_args[0]
         self.init_path()
         # create the shell
         self.init_shell()
         # and draw the banner
         self.init_banner()
         # Now a variety of things that happen after the banner is printed.
         self.init_gui_pylab()
         self.init_extensions()
         self.init_code()
 
     def init_shell(self):
         """initialize the InteractiveShell instance"""
         # Create an InteractiveShell instance.
         # shell.display_banner should always be False for the terminal
         # based app, because we call shell.show_banner() by hand below
         # so the banner shows *before* all extension loading stuff.
         self.shell = TerminalInteractiveShell.instance(parent=self,
                         display_banner=False, profile_dir=self.profile_dir,
                         ipython_dir=self.ipython_dir)
         self.shell.configurables.append(self)
 
     def init_banner(self):
         """optionally display the banner"""
         if self.display_banner and self.interact:
             self.shell.show_banner()
         # Make sure there is a space below the banner.
         if self.log_level <= logging.INFO: print
 
     def _pylab_changed(self, name, old, new):
         """Replace --pylab='inline' with --pylab='auto'"""
         if new == 'inline':
             warn.warn("'inline' not available as pylab backend, "
                       "using 'auto' instead.")
             self.pylab = 'auto'
 
     def start(self):
         if self.subapp is not None:
             return self.subapp.start()
         # perform any prexec steps:
         if self.interact:
             self.log.debug("Starting IPython's mainloop...")
             self.shell.mainloop()
         else:
             self.log.debug("IPython not interactive...")
 
 
 def load_default_config(ipython_dir=None):
     """Load the default config file from the default ipython_dir.
 
     This is useful for embedded shells.
     """
     if ipython_dir is None:
         ipython_dir = get_ipython_dir()
     profile_dir = os.path.join(ipython_dir, 'profile_default')
     cl = PyFileConfigLoader(default_config_file_name, profile_dir)
     try:
         config = cl.load_config()
     except ConfigFileNotFound:
         # no config found
         config = Config()
     return config
 
 
 def launch_new_instance():
     """Create and run a full blown IPython instance"""
     app = TerminalIPythonApp.instance()
     app.initialize()
     app.start()
 
 
 if __name__ == '__main__':
     launch_new_instance()

IPython/testing/iptest.py

@@ -1,624 +1,632 b''
 # -*- coding: utf-8 -*-
 """IPython Test Suite Runner.
 
 This module provides a main entry point to a user script to test IPython
 itself from the command line. There are two ways of running this script:
 
 1. With the syntax `iptest all`.  This runs our entire test suite by
    calling this script (with different arguments) recursively.  This
    causes modules and package to be tested in different processes, using nose
    or trial where appropriate.
 2. With the regular nose syntax, like `iptest -vvs IPython`.  In this form
    the script simply calls nose, but with special command line flags and
    plugins loaded.
 
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2009-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 # Stdlib
 import glob
 import os
 import os.path as path
 import signal
 import sys
 import subprocess
 import tempfile
 import time
 import warnings
 
 # Note: monkeypatch!
 # We need to monkeypatch a small problem in nose itself first, before importing
 # it for actual use.  This should get into nose upstream, but its release cycle
 # is slow and we need it for our parametric tests to work correctly.
 from IPython.testing import nosepatch
 
 # Monkeypatch extra assert methods into nose.tools if they're not already there.
 # This can be dropped once we no longer test on Python 2.6
 from IPython.testing import nose_assert_methods
 
 # Now, proceed to import nose itself
 import nose.plugins.builtin
 from nose.plugins.xunit import Xunit
 from nose import SkipTest
 from nose.core import TestProgram
 
 # Our own imports
 from IPython.utils import py3compat
 from IPython.utils.importstring import import_item
 from IPython.utils.path import get_ipython_module_path, get_ipython_package_dir
 from IPython.utils.process import find_cmd, pycmd2argv
 from IPython.utils.sysinfo import sys_info
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.utils.warn import warn
 
 from IPython.testing import globalipapp
 from IPython.testing.plugin.ipdoctest import IPythonDoctest
 from IPython.external.decorators import KnownFailure, knownfailureif
 
 pjoin = path.join
 
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 
 #-----------------------------------------------------------------------------
 # Warnings control
 #-----------------------------------------------------------------------------
 
 # Twisted generates annoying warnings with Python 2.6, as will do other code
 # that imports 'sets' as of today
 warnings.filterwarnings('ignore', 'the sets module is deprecated',
                         DeprecationWarning )
 
 # This one also comes from Twisted
 warnings.filterwarnings('ignore', 'the sha module is deprecated',
                         DeprecationWarning)
 
 # Wx on Fedora11 spits these out
 warnings.filterwarnings('ignore', 'wxPython/wxWidgets release number mismatch',
                         UserWarning)
 
 # ------------------------------------------------------------------------------
 # Monkeypatch Xunit to count known failures as skipped.
 # ------------------------------------------------------------------------------
 def monkeypatch_xunit():
     try:
         knownfailureif(True)(lambda: None)()
     except Exception as e:
         KnownFailureTest = type(e)
 
     def addError(self, test, err, capt=None):
         if issubclass(err[0], KnownFailureTest):
             err = (SkipTest,) + err[1:]
         return self.orig_addError(test, err, capt)
 
     Xunit.orig_addError = Xunit.addError
     Xunit.addError = addError
 
 #-----------------------------------------------------------------------------
 # Logic for skipping doctests
 #-----------------------------------------------------------------------------
 def extract_version(mod):
     return mod.__version__
 
 def test_for(item, min_version=None, callback=extract_version):
     """Test to see if item is importable, and optionally check against a minimum
     version.
 
     If min_version is given, the default behavior is to check against the
     `__version__` attribute of the item, but specifying `callback` allows you to
     extract the value you are interested in. e.g::
 
         In [1]: import sys
 
         In [2]: from IPython.testing.iptest import test_for
 
         In [3]: test_for('sys', (2,6), callback=lambda sys: sys.version_info)
         Out[3]: True
 
     """
     try:
         check = import_item(item)
     except (ImportError, RuntimeError):
         # GTK reports Runtime error if it can't be initialized even if it's
         # importable.
         return False
     else:
         if min_version:
             if callback:
                 # extra processing step to get version to compare
                 check = callback(check)
 
             return check >= min_version
         else:
             return True
 
 # Global dict where we can store information on what we have and what we don't
 # have available at test run time
 have = {}
 
 have['curses'] = test_for('_curses')
 have['matplotlib'] = test_for('matplotlib')
 have['numpy'] = test_for('numpy')
 have['pexpect'] = test_for('IPython.external.pexpect')
 have['pymongo'] = test_for('pymongo')
 have['pygments'] = test_for('pygments')
 have['qt'] = test_for('IPython.external.qt')
 have['rpy2'] = test_for('rpy2')
 have['sqlite3'] = test_for('sqlite3')
 have['cython'] = test_for('Cython')
 have['oct2py'] = test_for('oct2py')
 have['tornado'] = test_for('tornado.version_info', (2,1,0), callback=None)
 have['jinja2'] = test_for('jinja2')
 have['wx'] = test_for('wx')
 have['wx.aui'] = test_for('wx.aui')
 have['azure'] = test_for('azure')
+have['sphinx'] = test_for('sphinx')
+have['markdown'] = test_for('markdown')
 
 min_zmq = (2,1,11)
 
 have['zmq'] = test_for('zmq.pyzmq_version_info', min_zmq, callback=lambda x: x())
 
 #-----------------------------------------------------------------------------
 # Functions and classes
 #-----------------------------------------------------------------------------
 
 def report():
     """Return a string with a summary report of test-related variables."""
 
     out = [ sys_info(), '\n']
 
     avail = []
     not_avail = []
 
     for k, is_avail in have.items():
         if is_avail:
             avail.append(k)
         else:
             not_avail.append(k)
 
     if avail:
         out.append('\nTools and libraries available at test time:\n')
         avail.sort()
         out.append('   ' + ' '.join(avail)+'\n')
 
     if not_avail:
         out.append('\nTools and libraries NOT available at test time:\n')
         not_avail.sort()
         out.append('   ' + ' '.join(not_avail)+'\n')
 
     return ''.join(out)
 
 
 def make_exclude():
     """Make patterns of modules and packages to exclude from testing.
 
     For the IPythonDoctest plugin, we need to exclude certain patterns that
     cause testing problems.  We should strive to minimize the number of
     skipped modules, since this means untested code.
 
     These modules and packages will NOT get scanned by nose at all for tests.
     """
     # Simple utility to make IPython paths more readably, we need a lot of
     # these below
     ipjoin = lambda *paths: pjoin('IPython', *paths)
 
     exclusions = [ipjoin('external'),
                   ipjoin('quarantine'),
                   ipjoin('deathrow'),
                   # This guy is probably attic material
                   ipjoin('testing', 'mkdoctests'),
                   # Testing inputhook will need a lot of thought, to figure out
                   # how to have tests that don't lock up with the gui event
                   # loops in the picture
                   ipjoin('lib', 'inputhook'),
                   # Config files aren't really importable stand-alone
                   ipjoin('config', 'profile'),
                   # The notebook 'static' directory contains JS, css and other
                   # files for web serving.  Occasionally projects may put a .py
                   # file in there (MathJax ships a conf.py), so we might as
                   # well play it safe and skip the whole thing.
                   ipjoin('html', 'static'),
                   ipjoin('html', 'fabfile'),
                   ]
     if not have['sqlite3']:
         exclusions.append(ipjoin('core', 'tests', 'test_history'))
         exclusions.append(ipjoin('core', 'history'))
     if not have['wx']:
         exclusions.append(ipjoin('lib', 'inputhookwx'))
     
     if 'IPython.kernel.inprocess' not in sys.argv:
         exclusions.append(ipjoin('kernel', 'inprocess'))
     
     # FIXME: temporarily disable autoreload tests, as they can produce
     # spurious failures in subsequent tests (cythonmagic).
     exclusions.append(ipjoin('extensions', 'autoreload'))
     exclusions.append(ipjoin('extensions', 'tests', 'test_autoreload'))
 
     # We do this unconditionally, so that the test suite doesn't import
     # gtk, changing the default encoding and masking some unicode bugs.
     exclusions.append(ipjoin('lib', 'inputhookgtk'))
     exclusions.append(ipjoin('kernel', 'zmq', 'gui', 'gtkembed'))
 
     # These have to be skipped on win32 because the use echo, rm, cd, etc.
     # See ticket https://github.com/ipython/ipython/issues/87
     if sys.platform == 'win32':
         exclusions.append(ipjoin('testing', 'plugin', 'test_exampleip'))
         exclusions.append(ipjoin('testing', 'plugin', 'dtexample'))
 
     if not have['pexpect']:
         exclusions.extend([ipjoin('lib', 'irunner'),
                            ipjoin('lib', 'tests', 'test_irunner'),
                            ipjoin('terminal', 'console'),
                            ])
 
     if not have['zmq']:
         exclusions.append(ipjoin('kernel'))
         exclusions.append(ipjoin('qt'))
         exclusions.append(ipjoin('html'))
         exclusions.append(ipjoin('consoleapp.py'))
         exclusions.append(ipjoin('terminal', 'console'))
         exclusions.append(ipjoin('parallel'))
     elif not have['qt'] or not have['pygments']:
         exclusions.append(ipjoin('qt'))
 
     if not have['pymongo']:
         exclusions.append(ipjoin('parallel', 'controller', 'mongodb'))
         exclusions.append(ipjoin('parallel', 'tests', 'test_mongodb'))
 
     if not have['matplotlib']:
         exclusions.extend([ipjoin('core', 'pylabtools'),
                            ipjoin('core', 'tests', 'test_pylabtools'),
                            ipjoin('kernel', 'zmq', 'pylab'),
         ])
 
     if not have['cython']:
         exclusions.extend([ipjoin('extensions', 'cythonmagic')])
         exclusions.extend([ipjoin('extensions', 'tests', 'test_cythonmagic')])
 
     if not have['oct2py']:
         exclusions.extend([ipjoin('extensions', 'octavemagic')])
         exclusions.extend([ipjoin('extensions', 'tests', 'test_octavemagic')])
 
     if not have['tornado']:
         exclusions.append(ipjoin('html'))
 
     if not have['jinja2']:
         exclusions.append(ipjoin('html', 'notebookapp'))
 
     if not have['rpy2'] or not have['numpy']:
         exclusions.append(ipjoin('extensions', 'rmagic'))
         exclusions.append(ipjoin('extensions', 'tests', 'test_rmagic'))
 
     if not have['azure']:
         exclusions.append(ipjoin('html', 'services', 'notebooks', 'azurenbmanager'))
 
+    if not all((have['pygments'], have['jinja2'], have['markdown'], have['sphinx'])):
+        exclusions.append(ipjoin('nbconvert'))
+
     # This is needed for the reg-exp to match on win32 in the ipdoctest plugin.
     if sys.platform == 'win32':
         exclusions = [s.replace('\\','\\\\') for s in exclusions]
     
     # check for any exclusions that don't seem to exist:
     parent, _ = os.path.split(get_ipython_package_dir())
     for exclusion in exclusions:
         if exclusion.endswith(('deathrow', 'quarantine')):
             # ignore deathrow/quarantine, which exist in dev, but not install
             continue
         fullpath = pjoin(parent, exclusion)
         if not os.path.exists(fullpath) and not glob.glob(fullpath + '.*'):
             warn("Excluding nonexistent file: %r" % exclusion)
 
     return exclusions
 
 
 class IPTester(object):
     """Call that calls iptest or trial in a subprocess.
     """
     #: string, name of test runner that will be called
     runner = None
     #: list, parameters for test runner
     params = None
     #: list, arguments of system call to be made to call test runner
     call_args = None
     #: list, subprocesses we start (for cleanup)
     processes = None
     #: str, coverage xml output file
     coverage_xml = None
 
     def __init__(self, runner='iptest', params=None):
         """Create new test runner."""
         p = os.path
         if runner == 'iptest':
             iptest_app = os.path.abspath(get_ipython_module_path('IPython.testing.iptest'))
             self.runner = pycmd2argv(iptest_app) + sys.argv[1:]
         else:
             raise Exception('Not a valid test runner: %s' % repr(runner))
         if params is None:
             params = []
         if isinstance(params, str):
             params = [params]
         self.params = params
 
         # Assemble call
         self.call_args = self.runner+self.params
         
         # Find the section we're testing (IPython.foo)
         for sect in self.params:
             if sect.startswith('IPython') or sect in special_test_suites: break
         else:
             raise ValueError("Section not found", self.params)
         
         if '--with-xunit' in self.call_args:
             
             self.call_args.append('--xunit-file')
             # FIXME: when Windows uses subprocess.call, these extra quotes are unnecessary:
             xunit_file = path.abspath(sect+'.xunit.xml')
             if sys.platform == 'win32':
                 xunit_file = '"%s"' % xunit_file
             self.call_args.append(xunit_file)
         
         if '--with-xml-coverage' in self.call_args:
             self.coverage_xml = path.abspath(sect+".coverage.xml")
             self.call_args.remove('--with-xml-coverage')
             self.call_args = ["coverage", "run", "--source="+sect] + self.call_args[1:]
 
         # Store anything we start to clean up on deletion
         self.processes = []
 
     def _run_cmd(self):
         with TemporaryDirectory() as IPYTHONDIR:
             env = os.environ.copy()
             env['IPYTHONDIR'] = IPYTHONDIR
             # print >> sys.stderr, '*** CMD:', ' '.join(self.call_args) # dbg
             subp = subprocess.Popen(self.call_args, env=env)
             self.processes.append(subp)
             # If this fails, the process will be left in self.processes and
             # cleaned up later, but if the wait call succeeds, then we can
             # clear the stored process.
             retcode = subp.wait()
             self.processes.pop()
             return retcode
 
     def run(self):
         """Run the stored commands"""
         try:
             retcode = self._run_cmd()
         except KeyboardInterrupt:
             return -signal.SIGINT
         except:
             import traceback
             traceback.print_exc()
             return 1  # signal failure
         
         if self.coverage_xml:
             subprocess.call(["coverage", "xml", "-o", self.coverage_xml])
         return retcode
 
     def __del__(self):
         """Cleanup on exit by killing any leftover processes."""
         for subp in self.processes:
             if subp.poll() is not None:
                 continue # process is already dead
 
             try:
                 print('Cleaning up stale PID: %d' % subp.pid)
                 subp.kill()
             except: # (OSError, WindowsError) ?
                 # This is just a best effort, if we fail or the process was
                 # really gone, ignore it.
                 pass
             else:
                 for i in range(10):
                     if subp.poll() is None:
                         time.sleep(0.1)
                     else:
                         break
 
             if subp.poll() is None:
                 # The process did not die...
                 print('... failed. Manual cleanup may be required.')
 
 
 special_test_suites = {
     'autoreload': ['IPython.extensions.autoreload', 'IPython.extensions.tests.test_autoreload'],
 }
                 
 def make_runners(inc_slow=False):
     """Define the top-level packages that need to be tested.
     """
 
     # Packages to be tested via nose, that only depend on the stdlib
     nose_pkg_names = ['config', 'core', 'extensions', 'lib', 'terminal',
                       'testing', 'utils', 'nbformat' ]
 
     if have['qt']:
         nose_pkg_names.append('qt')
 
     if have['tornado']:
         nose_pkg_names.append('html')
         
     if have['zmq']:
         nose_pkg_names.append('kernel')
         nose_pkg_names.append('kernel.inprocess')
         if inc_slow:
             nose_pkg_names.append('parallel')
 
+    if all((have['pygments'], have['jinja2'], have['markdown'], have['sphinx'])):
+        nose_pkg_names.append('nbconvert')
+
     # For debugging this code, only load quick stuff
     #nose_pkg_names = ['core', 'extensions']  # dbg
 
     # Make fully qualified package names prepending 'IPython.' to our name lists
     nose_packages = ['IPython.%s' % m for m in nose_pkg_names ]
 
     # Make runners
     runners = [ (v, IPTester('iptest', params=v)) for v in nose_packages ]
     
     for name in special_test_suites:
         runners.append((name, IPTester('iptest', params=name)))
 
     return runners
 
 
 def run_iptest():
     """Run the IPython test suite using nose.
 
     This function is called when this script is **not** called with the form
     `iptest all`.  It simply calls nose with appropriate command line flags
     and accepts all of the standard nose arguments.
     """
     # Apply our monkeypatch to Xunit
     if '--with-xunit' in sys.argv and not hasattr(Xunit, 'orig_addError'):
         monkeypatch_xunit()
 
     warnings.filterwarnings('ignore',
         'This will be removed soon.  Use IPython.testing.util instead')
     
     if sys.argv[1] in special_test_suites:
         sys.argv[1:2] = special_test_suites[sys.argv[1]]
         special_suite = True
     else:
         special_suite = False
 
     argv = sys.argv + [ '--detailed-errors',  # extra info in tracebacks
 
                         '--with-ipdoctest',
                         '--ipdoctest-tests','--ipdoctest-extension=txt',
 
                         # We add --exe because of setuptools' imbecility (it
                         # blindly does chmod +x on ALL files).  Nose does the
                         # right thing and it tries to avoid executables,
                         # setuptools unfortunately forces our hand here.  This
                         # has been discussed on the distutils list and the
                         # setuptools devs refuse to fix this problem!
                         '--exe',
                         ]
     if '-a' not in argv and '-A' not in argv:
         argv = argv + ['-a', '!crash']
 
     if nose.__version__ >= '0.11':
         # I don't fully understand why we need this one, but depending on what
         # directory the test suite is run from, if we don't give it, 0 tests
         # get run.  Specifically, if the test suite is run from the source dir
         # with an argument (like 'iptest.py IPython.core', 0 tests are run,
         # even if the same call done in this directory works fine).  It appears
         # that if the requested package is in the current dir, nose bails early
         # by default.  Since it's otherwise harmless, leave it in by default
         # for nose >= 0.11, though unfortunately nose 0.10 doesn't support it.
         argv.append('--traverse-namespace')
 
     # use our plugin for doctesting.  It will remove the standard doctest plugin
     # if it finds it enabled
     ipdt = IPythonDoctest() if special_suite else IPythonDoctest(make_exclude())
     plugins = [ipdt, KnownFailure()]
     
     # We need a global ipython running in this process, but the special
     # in-process group spawns its own IPython kernels, so for *that* group we
     # must avoid also opening the global one (otherwise there's a conflict of
     # singletons).  Ultimately the solution to this problem is to refactor our
     # assumptions about what needs to be a singleton and what doesn't (app
     # objects should, individual shells shouldn't).  But for now, this
     # workaround allows the test suite for the inprocess module to complete.
     if not 'IPython.kernel.inprocess' in sys.argv:
         globalipapp.start_ipython()
 
     # Now nose can run
     TestProgram(argv=argv, addplugins=plugins)
 
 
 def run_iptestall(inc_slow=False):
     """Run the entire IPython test suite by calling nose and trial.
 
     This function constructs :class:`IPTester` instances for all IPython
     modules and package and then runs each of them.  This causes the modules
     and packages of IPython to be tested each in their own subprocess using
     nose.
     
     Parameters
     ----------
     
     inc_slow : bool, optional
       Include slow tests, like IPython.parallel. By default, these tests aren't
       run.
     """
 
     runners = make_runners(inc_slow=inc_slow)
 
     # Run the test runners in a temporary dir so we can nuke it when finished
     # to clean up any junk files left over by accident.  This also makes it
     # robust against being run in non-writeable directories by mistake, as the
     # temp dir will always be user-writeable.
     curdir = os.getcwdu()
     testdir = tempfile.gettempdir()
     os.chdir(testdir)
 
     # Run all test runners, tracking execution time
     failed = []
     t_start = time.time()
     try:
         for (name, runner) in runners:
             print('*'*70)
             print('IPython test group:',name)
             res = runner.run()
             if res:
                 failed.append( (name, runner) )
                 if res == -signal.SIGINT:
                     print("Interrupted")
                     break
     finally:
         os.chdir(curdir)
     t_end = time.time()
     t_tests = t_end - t_start
     nrunners = len(runners)
     nfail = len(failed)
     # summarize results
     print()
     print('*'*70)
     print('Test suite completed for system with the following information:')
     print(report())
     print('Ran %s test groups in %.3fs' % (nrunners, t_tests))
     print()
     print('Status:')
     if not failed:
         print('OK')
     else:
         # If anything went wrong, point out what command to rerun manually to
         # see the actual errors and individual summary
         print('ERROR - %s out of %s test groups failed.' % (nfail, nrunners))
         for name, failed_runner in failed:
             print('-'*40)
             print('Runner failed:',name)
             print('You may wish to rerun this one individually, with:')
             failed_call_args = [py3compat.cast_unicode(x) for x in failed_runner.call_args]
             print(u' '.join(failed_call_args))
             print()
         # Ensure that our exit code indicates failure
         sys.exit(1)
 
 
 def main():
     for arg in sys.argv[1:]:
         if arg.startswith('IPython') or arg in special_test_suites:
             # This is in-process
             run_iptest()
     else:
         if "--all" in sys.argv:
             sys.argv.remove("--all")
             inc_slow = True
         else:
             inc_slow = False
         # This starts subprocesses
         run_iptestall(inc_slow=inc_slow)
 
 
 if __name__ == '__main__':
     main()

setup.py

@@ -1,347 +1,348 b''
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 """Setup script for IPython.
 
 Under Posix environments it works like a typical setup.py script.
 Under Windows, the command sdist is not supported, since IPython
 requires utilities which are not available under Windows."""
 
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2008-2011, IPython Development Team.
 #  Copyright (c) 2001-2007, Fernando Perez <[e-mail]>
 #  Copyright (c) 2001, Janko Hauser <[e-mail]>
 #  Copyright (c) 2001, Nathaniel Gray <[e-mail]>
 #
 #  Distributed under the terms of the Modified BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Minimal Python version sanity check
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 import sys
 
 # This check is also made in IPython/__init__, don't forget to update both when
 # changing Python version requirements.
 #~ if sys.version[0:3] < '2.6':
     #~ error = """\
 #~ ERROR: 'IPython requires Python Version 2.6 or above.'
 #~ Exiting."""
     #~ print >> sys.stderr, error
     #~ sys.exit(1)
 
 PY3 = (sys.version_info[0] >= 3)
 
 # At least we're on the python version we need, move on.
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 # Stdlib imports
 import os
 import shutil
 
 from glob import glob
 
 # BEFORE importing distutils, remove MANIFEST. distutils doesn't properly
 # update it when the contents of directories change.
 if os.path.exists('MANIFEST'): os.remove('MANIFEST')
 
 from distutils.core import setup
 
 # On Python 3, we need distribute (new setuptools) to do the 2to3 conversion
 if PY3:
     import setuptools
 
 # Our own imports
 from setupbase import target_update
 
 from setupbase import (
     setup_args,
     find_packages,
     find_package_data,
     find_scripts,
     find_data_files,
     check_for_dependencies,
     git_prebuild,
     check_submodule_status,
     update_submodules,
     require_submodules,
     UpdateSubmodules,
 )
 from setupext import setupext
 
 isfile = os.path.isfile
 pjoin = os.path.join
 
 #-----------------------------------------------------------------------------
 # Function definitions
 #-----------------------------------------------------------------------------
 
 def cleanup():
     """Clean up the junk left around by the build process"""
     if "develop" not in sys.argv and "egg_info" not in sys.argv:
         try:
             shutil.rmtree('ipython.egg-info')
         except:
             try:
                 os.unlink('ipython.egg-info')
             except:
                 pass
 
 #-------------------------------------------------------------------------------
 # Handle OS specific things
 #-------------------------------------------------------------------------------
 
 if os.name in ('nt','dos'):
     os_name = 'windows'
 else:
     os_name = os.name
 
 # Under Windows, 'sdist' has not been supported.  Now that the docs build with
 # Sphinx it might work, but let's not turn it on until someone confirms that it
 # actually works.
 if os_name == 'windows' and 'sdist' in sys.argv:
     print('The sdist command is not available under Windows.  Exiting.')
     sys.exit(1)
 
 #-------------------------------------------------------------------------------
 # Make sure we aren't trying to run without submodules
 #-------------------------------------------------------------------------------
 here = os.path.abspath(os.path.dirname(__file__))
 
 def require_clean_submodules():
     """Check on git submodules before distutils can do anything
 
     Since distutils cannot be trusted to update the tree
     after everything has been set in motion,
     this is not a distutils command.
     """
     # PACKAGERS: Add a return here to skip checks for git submodules
     
     # don't do anything if nothing is actually supposed to happen
     for do_nothing in ('-h', '--help', '--help-commands', 'clean', 'submodule'):
         if do_nothing in sys.argv:
             return
 
     status = check_submodule_status(here)
 
     if status == "missing":
         print("checking out submodules for the first time")
         update_submodules(here)
     elif status == "unclean":
         print('\n'.join([
             "Cannot build / install IPython with unclean submodules",
             "Please update submodules with",
             "    python setup.py submodule",
             "or",
             "    git submodule update",
             "or commit any submodule changes you have made."
         ]))
         sys.exit(1)
 
 require_clean_submodules()
 
 #-------------------------------------------------------------------------------
 # Things related to the IPython documentation
 #-------------------------------------------------------------------------------
 
 # update the manuals when building a source dist
 if len(sys.argv) >= 2 and sys.argv[1] in ('sdist','bdist_rpm'):
     import textwrap
 
     # List of things to be updated. Each entry is a triplet of args for
     # target_update()
     to_update = [
                   # FIXME - Disabled for now: we need to redo an automatic way
                   # of generating the magic info inside the rst.
                   #('docs/magic.tex',
                   #['IPython/Magic.py'],
                   #"cd doc && ./update_magic.sh" ),
 
                  ('docs/man/ipcluster.1.gz',
                   ['docs/man/ipcluster.1'],
                   'cd docs/man && gzip -9c ipcluster.1 > ipcluster.1.gz'),
 
                  ('docs/man/ipcontroller.1.gz',
                   ['docs/man/ipcontroller.1'],
                   'cd docs/man && gzip -9c ipcontroller.1 > ipcontroller.1.gz'),
 
                  ('docs/man/ipengine.1.gz',
                   ['docs/man/ipengine.1'],
                   'cd docs/man && gzip -9c ipengine.1 > ipengine.1.gz'),
 
                  ('docs/man/iplogger.1.gz',
                   ['docs/man/iplogger.1'],
                   'cd docs/man && gzip -9c iplogger.1 > iplogger.1.gz'),
 
                  ('docs/man/ipython.1.gz',
                   ['docs/man/ipython.1'],
                   'cd docs/man && gzip -9c ipython.1 > ipython.1.gz'),
 
                  ('docs/man/irunner.1.gz',
                   ['docs/man/irunner.1'],
                   'cd docs/man && gzip -9c irunner.1 > irunner.1.gz'),
 
                  ('docs/man/pycolor.1.gz',
                   ['docs/man/pycolor.1'],
                   'cd docs/man && gzip -9c pycolor.1 > pycolor.1.gz'),
                  ]
 
 
     [ target_update(*t) for t in to_update ]
 
 #---------------------------------------------------------------------------
 # Find all the packages, package data, and data_files
 #---------------------------------------------------------------------------
 
 packages = find_packages()
 package_data = find_package_data()
 data_files = find_data_files()
 
 setup_args['packages'] = packages
 setup_args['package_data'] = package_data
 setup_args['data_files'] = data_files
 
 #---------------------------------------------------------------------------
 # custom distutils commands
 #---------------------------------------------------------------------------
 # imports here, so they are after setuptools import if there was one
 from distutils.command.sdist import sdist
 from distutils.command.upload import upload
 
 class UploadWindowsInstallers(upload):
 
     description = "Upload Windows installers to PyPI (only used from tools/release_windows.py)"
     user_options = upload.user_options + [
         ('files=', 'f', 'exe file (or glob) to upload')
     ]
     def initialize_options(self):
         upload.initialize_options(self)
         meta = self.distribution.metadata
         base = '{name}-{version}'.format(
             name=meta.get_name(),
             version=meta.get_version()
         )
         self.files = os.path.join('dist', '%s.*.exe' % base)
 
     def run(self):
         for dist_file in glob(self.files):
             self.upload_file('bdist_wininst', 'any', dist_file)
 
 setup_args['cmdclass'] = {
     'build_py': git_prebuild('IPython'),
     'sdist' : git_prebuild('IPython', sdist),
     'upload_wininst' : UploadWindowsInstallers,
     'submodule' : UpdateSubmodules,
 }
 
 #---------------------------------------------------------------------------
 # Handle scripts, dependencies, and setuptools specific things
 #---------------------------------------------------------------------------
 
 # For some commands, use setuptools.  Note that we do NOT list install here!
 # If you want a setuptools-enhanced install, just run 'setupegg.py install'
 needs_setuptools = set(('develop', 'release', 'bdist_egg', 'bdist_rpm',
            'bdist', 'bdist_dumb', 'bdist_wininst', 'install_egg_info',
            'egg_info', 'easy_install', 'upload',
             ))
 if sys.platform == 'win32':
     # Depend on setuptools for install on *Windows only*
     # If we get script-installation working without setuptools,
     # then we can back off, but until then use it.
     # See Issue #369 on GitHub for more
     needs_setuptools.add('install')
 
 if len(needs_setuptools.intersection(sys.argv)) > 0:
     import setuptools
 
 # This dict is used for passing extra arguments that are setuptools
 # specific to setup
 setuptools_extra_args = {}
 
 if 'setuptools' in sys.modules:
     # setup.py develop should check for submodules
     from setuptools.command.develop import develop
     setup_args['cmdclass']['develop'] = require_submodules(develop)
     
     setuptools_extra_args['zip_safe'] = False
     setuptools_extra_args['entry_points'] = find_scripts(True)
     setup_args['extras_require'] = dict(
         parallel = 'pyzmq>=2.1.11',
         qtconsole = ['pyzmq>=2.1.11', 'pygments'],
         zmq = 'pyzmq>=2.1.11',
         doc = 'Sphinx>=0.3',
         test = 'nose>=0.10.1',
         notebook = ['tornado>=2.0', 'pyzmq>=2.1.11', 'jinja2'],
+        nbconvert = ['pygments', 'markdown', 'jinja2', 'Sphinx>=0.3']
     )
     requires = setup_args.setdefault('install_requires', [])
     setupext.display_status = False
     if not setupext.check_for_readline():
         if sys.platform == 'darwin':
             requires.append('readline')
         elif sys.platform.startswith('win'):
             # Pyreadline 64 bit windows issue solved in versions >=1.7.1
             # Also solves issues with some older versions of pyreadline that
             # satisfy the unconstrained depdendency.
             requires.append('pyreadline>=1.7.1')
         else:
             pass
             # do we want to install readline here?
 
     # Script to be run by the windows binary installer after the default setup
     # routine, to add shortcuts and similar windows-only things.  Windows
     # post-install scripts MUST reside in the scripts/ dir, otherwise distutils
     # doesn't find them.
     if 'bdist_wininst' in sys.argv:
         if len(sys.argv) > 2 and \
                ('sdist' in sys.argv or 'bdist_rpm' in sys.argv):
             print >> sys.stderr, "ERROR: bdist_wininst must be run alone. Exiting."
             sys.exit(1)
         setup_args['data_files'].append(
             ['Scripts', ('scripts/ipython.ico', 'scripts/ipython_nb.ico')])
         setup_args['scripts'] = [pjoin('scripts','ipython_win_post_install.py')]
         setup_args['options'] = {"bdist_wininst":
                                  {"install_script":
                                   "ipython_win_post_install.py"}}
 
     if PY3:
         setuptools_extra_args['use_2to3'] = True
         # we try to make a 2.6, 2.7, and 3.1 to 3.3 python compatible code
         # so we explicitly disable some 2to3 fixes to be sure we aren't forgetting
         # anything.
         setuptools_extra_args['use_2to3_exclude_fixers'] = [
                 'lib2to3.fixes.fix_apply',
                 'lib2to3.fixes.fix_except',
                 'lib2to3.fixes.fix_has_key',
                 'lib2to3.fixes.fix_next',
                 'lib2to3.fixes.fix_repr',
                 'lib2to3.fixes.fix_tuple_params',
                 ]
         from setuptools.command.build_py import build_py
         setup_args['cmdclass'] = {'build_py': git_prebuild('IPython', build_cmd=build_py)}
         setuptools_extra_args['entry_points'] = find_scripts(True, suffix='3')
         setuptools._dont_write_bytecode = True
 else:
     # If we are running without setuptools, call this function which will
     # check for dependencies an inform the user what is needed.  This is
     # just to make life easy for users.
     check_for_dependencies()
     setup_args['scripts'] = find_scripts(False)
 
 #---------------------------------------------------------------------------
 # Do the actual setup now
 #---------------------------------------------------------------------------
 
 setup_args.update(setuptools_extra_args)
 
 def main():
     setup(**setup_args)
     cleanup()
 
 if __name__ == '__main__':
     main()

setupbase.py

@@ -1,469 +1,474 b''
 # encoding: utf-8
 """
 This module defines the things that are used in setup.py for building IPython
 
 This includes:
 
     * The basic arguments to setup
     * Functions for finding things like packages, package data, etc.
     * A function for checking dependencies.
 """
 from __future__ import print_function
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 import os
 import sys
 
 try:
     from configparser import ConfigParser
 except:
     from ConfigParser import ConfigParser
 from distutils.command.build_py import build_py
 from distutils.cmd import Command
 from glob import glob
 
 from setupext import install_data_ext
 
 #-------------------------------------------------------------------------------
 # Useful globals and utility functions
 #-------------------------------------------------------------------------------
 
 # A few handy globals
 isfile = os.path.isfile
 pjoin = os.path.join
 repo_root = os.path.dirname(os.path.abspath(__file__))
 
 def oscmd(s):
     print(">", s)
     os.system(s)
 
 # Py3 compatibility hacks, without assuming IPython itself is installed with
 # the full py3compat machinery.
 
 try:
     execfile
 except NameError:
     def execfile(fname, globs, locs=None):
         locs = locs or globs
         exec(compile(open(fname).read(), fname, "exec"), globs, locs)
 
 # A little utility we'll need below, since glob() does NOT allow you to do
 # exclusion on multiple endings!
 def file_doesnt_endwith(test,endings):
     """Return true if test is a file and its name does NOT end with any
     of the strings listed in endings."""
     if not isfile(test):
         return False
     for e in endings:
         if test.endswith(e):
             return False
     return True
 
 #---------------------------------------------------------------------------
 # Basic project information
 #---------------------------------------------------------------------------
 
 # release.py contains version, authors, license, url, keywords, etc.
 execfile(pjoin(repo_root, 'IPython','core','release.py'), globals())
 
 # Create a dict with the basic information
 # This dict is eventually passed to setup after additional keys are added.
 setup_args = dict(
       name             = name,
       version          = version,
       description      = description,
       long_description = long_description,
       author           = author,
       author_email     = author_email,
       url              = url,
       download_url     = download_url,
       license          = license,
       platforms        = platforms,
       keywords         = keywords,
       classifiers      = classifiers,
       cmdclass         = {'install_data': install_data_ext},
       )
 
 
 #---------------------------------------------------------------------------
 # Find packages
 #---------------------------------------------------------------------------
 
 def find_packages():
     """
     Find all of IPython's packages.
     """
     excludes = ['deathrow', 'quarantine']
     packages = []
     for dir,subdirs,files in os.walk('IPython'):
         package = dir.replace(os.path.sep, '.')
         if any(package.startswith('IPython.'+exc) for exc in excludes):
             # package is to be excluded (e.g. deathrow)
             continue
         if '__init__.py' not in files:
             # not a package
             continue
         packages.append(package)
     return packages
 
 #---------------------------------------------------------------------------
 # Find package data
 #---------------------------------------------------------------------------
 
 def find_package_data():
     """
     Find IPython's package_data.
     """
     # This is not enough for these things to appear in an sdist.
     # We need to muck with the MANIFEST to get this to work
     
     # exclude static things that we don't ship (e.g. mathjax)
     excludes = ['mathjax']
     
     # add 'static/' prefix to exclusions, and tuplify for use in startswith
     excludes = tuple([os.path.join('static', ex) for ex in excludes])
     
     # walk notebook resources:
     cwd = os.getcwd()
     os.chdir(os.path.join('IPython', 'html'))
     static_walk = list(os.walk('static'))
     os.chdir(cwd)
     static_data = []
     for parent, dirs, files in static_walk:
         if parent.startswith(excludes):
             continue
         for f in files:
             static_data.append(os.path.join(parent, f))
 
     package_data = {
         'IPython.config.profile' : ['README*', '*/*.py'],
         'IPython.core.tests' : ['*.png', '*.jpg'],
         'IPython.testing' : ['*.txt'],
         'IPython.testing.plugin' : ['*.txt'],
         'IPython.html' : ['templates/*'] + static_data,
         'IPython.qt.console' : ['resources/icon/*.svg'],
+        'IPython.nbconvert.templates' : ['*.tpl', 'latex/*.tpl',
+            'latex/skeleton/*.tplx', 'skeleton/*']
     }
     return package_data
 
 
 #---------------------------------------------------------------------------
 # Find data files
 #---------------------------------------------------------------------------
 
 def make_dir_struct(tag,base,out_base):
     """Make the directory structure of all files below a starting dir.
 
     This is just a convenience routine to help build a nested directory
     hierarchy because distutils is too stupid to do this by itself.
 
     XXX - this needs a proper docstring!
     """
 
     # we'll use these a lot below
     lbase = len(base)
     pathsep = os.path.sep
     lpathsep = len(pathsep)
 
     out = []
     for (dirpath,dirnames,filenames) in os.walk(base):
         # we need to strip out the dirpath from the base to map it to the
         # output (installation) path.  This requires possibly stripping the
         # path separator, because otherwise pjoin will not work correctly
         # (pjoin('foo/','/bar') returns '/bar').
 
         dp_eff = dirpath[lbase:]
         if dp_eff.startswith(pathsep):
             dp_eff = dp_eff[lpathsep:]
         # The output path must be anchored at the out_base marker
         out_path = pjoin(out_base,dp_eff)
         # Now we can generate the final filenames. Since os.walk only produces
         # filenames, we must join back with the dirpath to get full valid file
         # paths:
         pfiles = [pjoin(dirpath,f) for f in filenames]
         # Finally, generate the entry we need, which is a pari of (output
         # path, files) for use as a data_files parameter in install_data.
         out.append((out_path, pfiles))
 
     return out
 
 
 def find_data_files():
     """
     Find IPython's data_files.
 
     Most of these are docs.
     """
 
     docdirbase  = pjoin('share', 'doc', 'ipython')
     manpagebase = pjoin('share', 'man', 'man1')
 
     # Simple file lists can be made by hand
     manpages = [f for f in glob(pjoin('docs','man','*.1.gz')) if isfile(f)]
     if not manpages:
         # When running from a source tree, the manpages aren't gzipped
         manpages = [f for f in glob(pjoin('docs','man','*.1')) if isfile(f)]
 
     igridhelpfiles = [f for f in glob(pjoin('IPython','extensions','igrid_help.*')) if isfile(f)]
 
     # For nested structures, use the utility above
     example_files = make_dir_struct(
         'data',
         pjoin('docs','examples'),
         pjoin(docdirbase,'examples')
     )
     manual_files = make_dir_struct(
         'data',
         pjoin('docs','html'),
         pjoin(docdirbase,'manual')
     )
 
     # And assemble the entire output list
     data_files = [ (manpagebase, manpages),
                    (pjoin(docdirbase, 'extensions'), igridhelpfiles),
                    ] + manual_files + example_files
 
     return data_files
 
 
 def make_man_update_target(manpage):
     """Return a target_update-compliant tuple for the given manpage.
 
     Parameters
     ----------
     manpage : string
       Name of the manpage, must include the section number (trailing number).
 
     Example
     -------
 
     >>> make_man_update_target('ipython.1') #doctest: +NORMALIZE_WHITESPACE
     ('docs/man/ipython.1.gz',
      ['docs/man/ipython.1'],
      'cd docs/man && gzip -9c ipython.1 > ipython.1.gz')
     """
     man_dir = pjoin('docs', 'man')
     manpage_gz = manpage + '.gz'
     manpath = pjoin(man_dir, manpage)
     manpath_gz = pjoin(man_dir, manpage_gz)
     gz_cmd = ( "cd %(man_dir)s && gzip -9c %(manpage)s > %(manpage_gz)s" %
                locals() )
     return (manpath_gz, [manpath], gz_cmd)
 
 # The two functions below are copied from IPython.utils.path, so we don't need
 # to import IPython during setup, which fails on Python 3.
 
 def target_outdated(target,deps):
     """Determine whether a target is out of date.
 
     target_outdated(target,deps) -> 1/0
 
     deps: list of filenames which MUST exist.
     target: single filename which may or may not exist.
 
     If target doesn't exist or is older than any file listed in deps, return
     true, otherwise return false.
     """
     try:
         target_time = os.path.getmtime(target)
     except os.error:
         return 1
     for dep in deps:
         dep_time = os.path.getmtime(dep)
         if dep_time > target_time:
             #print "For target",target,"Dep failed:",dep # dbg
             #print "times (dep,tar):",dep_time,target_time # dbg
             return 1
     return 0
 
 
 def target_update(target,deps,cmd):
     """Update a target with a given command given a list of dependencies.
 
     target_update(target,deps,cmd) -> runs cmd if target is outdated.
 
     This is just a wrapper around target_outdated() which calls the given
     command if target is outdated."""
 
     if target_outdated(target,deps):
         os.system(cmd)
 
 #---------------------------------------------------------------------------
 # Find scripts
 #---------------------------------------------------------------------------
 
 def find_scripts(entry_points=False, suffix=''):
     """Find IPython's scripts.
 
     if entry_points is True:
         return setuptools entry_point-style definitions
     else:
         return file paths of plain scripts [default]
 
     suffix is appended to script names if entry_points is True, so that the
     Python 3 scripts get named "ipython3" etc.
     """
     if entry_points:
         console_scripts = [s % suffix for s in [
             'ipython%s = IPython.terminal.ipapp:launch_new_instance',
             'pycolor%s = IPython.utils.PyColorize:main',
             'ipcontroller%s = IPython.parallel.apps.ipcontrollerapp:launch_new_instance',
             'ipengine%s = IPython.parallel.apps.ipengineapp:launch_new_instance',
             'iplogger%s = IPython.parallel.apps.iploggerapp:launch_new_instance',
             'ipcluster%s = IPython.parallel.apps.ipclusterapp:launch_new_instance',
             'iptest%s = IPython.testing.iptest:main',
-            'irunner%s = IPython.lib.irunner:main'
+            'irunner%s = IPython.lib.irunner:main',
         ]]
         gui_scripts = []
         scripts = dict(console_scripts=console_scripts, gui_scripts=gui_scripts)
     else:
         parallel_scripts = pjoin('IPython','parallel','scripts')
         main_scripts = pjoin('IPython','scripts')
         scripts = [
                    pjoin(parallel_scripts, 'ipengine'),
                    pjoin(parallel_scripts, 'ipcontroller'),
                    pjoin(parallel_scripts, 'ipcluster'),
                    pjoin(parallel_scripts, 'iplogger'),
                    pjoin(main_scripts, 'ipython'),
                    pjoin(main_scripts, 'pycolor'),
                    pjoin(main_scripts, 'irunner'),
                    pjoin(main_scripts, 'iptest')
         ]
     return scripts
 
 #---------------------------------------------------------------------------
 # Verify all dependencies
 #---------------------------------------------------------------------------
 
 def check_for_dependencies():
     """Check for IPython's dependencies.
 
     This function should NOT be called if running under setuptools!
     """
     from setupext.setupext import (
         print_line, print_raw, print_status,
         check_for_sphinx, check_for_pygments,
         check_for_nose, check_for_pexpect,
-        check_for_pyzmq, check_for_readline
+        check_for_pyzmq, check_for_readline,
+        check_for_jinja2, check_for_markdown
     )
     print_line()
     print_raw("BUILDING IPYTHON")
     print_status('python', sys.version)
     print_status('platform', sys.platform)
     if sys.platform == 'win32':
         print_status('Windows version', sys.getwindowsversion())
 
     print_raw("")
     print_raw("OPTIONAL DEPENDENCIES")
 
     check_for_sphinx()
     check_for_pygments()
     check_for_nose()
     check_for_pexpect()
     check_for_pyzmq()
     check_for_readline()
+    check_for_jinja2()
+    check_for_markdown()
 
 #---------------------------------------------------------------------------
 # VCS related
 #---------------------------------------------------------------------------
 
 # utils.submodule has checks for submodule status
 execfile(pjoin('IPython','utils','submodule.py'), globals())
 
 class UpdateSubmodules(Command):
     """Update git submodules
     
     IPython's external javascript dependencies live in a separate repo.
     """
     description = "Update git submodules"
     user_options = []
     
     def initialize_options(self):
         pass
     
     def finalize_options(self):
         pass
     
     def run(self):
         failure = False
         try:
             self.spawn('git submodule init'.split())
             self.spawn('git submodule update --recursive'.split())
         except Exception as e:
             failure = e
             print(e)
         
         if not check_submodule_status(repo_root) == 'clean':
             print("submodules could not be checked out")
             sys.exit(1)
 
 
 def git_prebuild(pkg_dir, build_cmd=build_py):
     """Return extended build or sdist command class for recording commit
     
     records git commit in IPython.utils._sysinfo.commit
     
     for use in IPython.utils.sysinfo.sys_info() calls after installation.
     
     Also ensures that submodules exist prior to running
     """
     
     class MyBuildPy(build_cmd):
         ''' Subclass to write commit data into installation tree '''
         def run(self):
             build_cmd.run(self)
             # this one will only fire for build commands
             if hasattr(self, 'build_lib'):
                 self._record_commit(self.build_lib)
         
         def make_release_tree(self, base_dir, files):
             # this one will fire for sdist
             build_cmd.make_release_tree(self, base_dir, files)
             self._record_commit(base_dir)
         
         def _record_commit(self, base_dir):
             import subprocess
             proc = subprocess.Popen('git rev-parse --short HEAD',
                                     stdout=subprocess.PIPE,
                                     stderr=subprocess.PIPE,
                                     shell=True)
             repo_commit, _ = proc.communicate()
             repo_commit = repo_commit.strip().decode("ascii")
             
             out_pth = pjoin(base_dir, pkg_dir, 'utils', '_sysinfo.py')
             if os.path.isfile(out_pth) and not repo_commit:
                 # nothing to write, don't clobber
                 return
             
             print("writing git commit '%s' to %s" % (repo_commit, out_pth))
             
             # remove to avoid overwriting original via hard link
             try:
                 os.remove(out_pth)
             except (IOError, OSError):
                 pass
             with open(out_pth, 'w') as out_file:
                 out_file.writelines([
                     '# GENERATED BY setup.py\n',
                     'commit = "%s"\n' % repo_commit,
                 ])
     return require_submodules(MyBuildPy)
 
 
 def require_submodules(command):
     """decorator for instructing a command to check for submodules before running"""
     class DecoratedCommand(command):
         def run(self):
             if not check_submodule_status(repo_root) == 'clean':
                 print("submodules missing! Run `setup.py submodule` and try again")
                 sys.exit(1)
             command.run(self)
     return DecoratedCommand

setupext/setupext.py

@@ -1,172 +1,162 b''
 # encoding: utf-8
 from __future__ import print_function
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import sys, os
 from textwrap import fill
 
 display_status=True
 
 def check_display(f):
     """decorator to allow display methods to be muted by mod.display_status"""
     def maybe_display(*args, **kwargs):
         if display_status:
             return f(*args, **kwargs)
     return maybe_display
 
 @check_display
 def print_line(char='='):
     print(char * 76)
 
 @check_display
 def print_status(package, status):
     initial_indent = "%22s: " % package
     indent = ' ' * 24
     print(fill(str(status), width=76,
                initial_indent=initial_indent,
                subsequent_indent=indent))
 
 @check_display
 def print_message(message):
     indent = ' ' * 24 + "* "
     print(fill(str(message), width=76,
                initial_indent=indent,
                subsequent_indent=indent))
 
 @check_display
 def print_raw(section):
     print(section)
 
 #-------------------------------------------------------------------------------
 # Tests for specific packages
 #-------------------------------------------------------------------------------
 
 def check_for_ipython():
     try:
         import IPython
     except ImportError:
         print_status("IPython", "Not found")
         return False
     else:
         print_status("IPython", IPython.__version__)
         return True
 
 def check_for_sphinx():
     try:
         import sphinx
     except ImportError:
-        print_status('sphinx', "Not found (required for building documentation)")
+        print_status('sphinx', "Not found (required for docs and nbconvert)")
         return False
     else:
         print_status('sphinx', sphinx.__version__)
         return True
 
 def check_for_pygments():
     try:
         import pygments
     except ImportError:
-        print_status('pygments', "Not found (required for syntax highlighting documentation)")
+        print_status('pygments', "Not found (required for docs and nbconvert)")
         return False
     else:
         print_status('pygments', pygments.__version__)
         return True
 
-def check_for_nose():
-    try:
-        import nose
-    except ImportError:
-        print_status('nose', "Not found (required for running the test suite)")
-        return False
-    else:
-        print_status('nose', nose.__version__)
-        return True
-
-def check_for_pexpect():
+def check_for_jinja2():
     try:
-        import pexpect
+        import jinja2
     except ImportError:
-        print_status("pexpect", "no (required for running standalone doctests)")
+        print_status('jinja2', "Not found (required for notebook and nbconvert)")
         return False
     else:
-        print_status("pexpect", pexpect.__version__)
+        print_status('jinja2', jinja2.__version__)
         return True
 
-def check_for_httplib2():
+def check_for_markdown():
     try:
-        import httplib2
+        import markdown
     except ImportError:
-        print_status("httplib2", "no (required for blocking http clients)")
+        print_status('pygments', "Not found (required for nbconvert)")
         return False
     else:
-        print_status("httplib2","yes")
+        print_status('markdown', markdown.version)
         return True
 
-def check_for_sqlalchemy():
+def check_for_nose():
     try:
-        import sqlalchemy
+        import nose
     except ImportError:
-        print_status("sqlalchemy", "no (required for the ipython1 notebook)")
+        print_status('nose', "Not found (required for running the test suite)")
         return False
     else:
-        print_status("sqlalchemy","yes")
+        print_status('nose', nose.__version__)
         return True
 
-def check_for_simplejson():
+def check_for_pexpect():
     try:
-        import simplejson
+        import pexpect
     except ImportError:
-        print_status("simplejson", "no (required for the ipython1 notebook)")
+        print_status("pexpect", "no (required for running standalone doctests)")
         return False
     else:
-        print_status("simplejson","yes")
+        print_status("pexpect", pexpect.__version__)
         return True
 
 def check_for_pyzmq():
     try:
         import zmq
     except ImportError:
         print_status('pyzmq', "no (required for qtconsole, notebook, and parallel computing capabilities)")
         return False
     else:
         # pyzmq 2.1.10 adds pyzmq_version_info funtion for returning
         # version as a tuple
         if hasattr(zmq, 'pyzmq_version_info') and zmq.pyzmq_version_info() >= (2,1,11):
                 print_status("pyzmq", zmq.__version__)
                 return True
         else:
             print_status('pyzmq', "no (have %s, but require >= 2.1.11 for"
             " qtconsole, notebook, and parallel computing capabilities)" % zmq.__version__)
             return False
 
 def check_for_readline():
     from distutils.version import LooseVersion
     try:
         import readline
     except ImportError:
         try:
             import pyreadline
             vs = pyreadline.release.version
         except (ImportError, AttributeError):
             print_status('readline', "no (required for good interactive behavior)")
             return False
         if LooseVersion(vs).version >= [1,7,1]:
             print_status('readline', "yes pyreadline-" + vs)
             return True
         else:
             print_status('readline', "no pyreadline-%s < 1.7.1" % vs)
             return False
     else:
         print_status('readline', "yes")
         return True