Changes after in person review with @ellisonbg including TODO tags

IPython/nbconvert/exporters/export.py

@@ -1,220 +1,220
 """
 Module containing single call export functions.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from functools import wraps
 
 from IPython.nbformat.v3.nbbase import NotebookNode
 from IPython.config import Config
 
 from .exporter import Exporter
 from .basichtml import BasicHTMLExporter
 from .fullhtml import FullHTMLExporter
 from .latex import LatexExporter
 from .markdown import MarkdownExporter
 from .python import PythonExporter
 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 (optional, keyword arg)
         User configuration instance.
     resources : dict (optional, keyword arg)
         Resources used in the conversion process.
         
     Returns
     ----------
     tuple- output, resources, exporter_instance
     output : str
         Jinja 2 output.  This is the resulting converted notebook.
     resources : dictionary
         Dictionary of resources used prior to and during the conversion 
         process.
     exporter_instance : Exporter
         Instance of the Exporter class used to export the document.  Useful
         to caller because it provides a 'file_extension' property which
         specifies what extension the output should be saved as."""
             
     @wraps(f)
     def decorator(*args, **kwargs):
         return f(*args, **kwargs)
     
     return decorator
 
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 __all__ = [
     'export',
     'export_sphinx_manual',
     'export_sphinx_howto',
     'export_basic_html',
     'export_full_html',
     'export_latex',
     'export_markdown',
     'export_python',
     'export_reveal',
     'export_rst',
     'export_by_name',
     'get_export_names'
 ]
 
 class ExporterNameError(NameError):
     pass
 
 @DocDecorator
 def export(exporter_type, nb, **kw):
     """
     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(config=kw.get('config', Config()))
+    resources = kw.pop('resources', None)
+    exporter_instance = exporter_type(**kw)
 
     #Try to convert the notebook using the appropriate conversion function.
-    resources = kw.get('resources', {})
     if isinstance(nb, NotebookNode):
         output, resources = exporter_instance.from_notebook_node(nb, resources)
     elif isinstance(nb, basestring):
         output, resources = exporter_instance.from_filename(nb, resources)
     else:
         output, resources = exporter_instance.from_file(nb, resources)
     return output, resources
 
 
 @DocDecorator
 def export_sphinx_manual(nb, **kw):
     """
     Export a notebook object to Sphinx Manual LaTeX
     """
     return export(SphinxManualExporter, nb, **kw)
 
 
 @DocDecorator
 def export_sphinx_howto(nb, **kw):
     """
     Export a notebook object to Sphinx HowTo LaTeX
     """
     return export(SphinxHowtoExporter, nb, **kw)
 
 
 @DocDecorator
 def export_basic_html(nb, **kw):
     """
     Export a notebook object to Basic HTML
     """
     return export(BasicHTMLExporter, nb, **kw)
 
 
 @DocDecorator
 def export_full_html(nb, **kw):
     """
     Export a notebook object to Full HTML
     """
     return export(FullHTMLExporter, nb, **kw)
 
 
 @DocDecorator
 def export_latex(nb, **kw):
     """
     Export a notebook object to LaTeX
     """
     return export(LatexExporter, nb, **kw)
 
 
 @DocDecorator
 def export_markdown(nb, **kw):
     """
     Export a notebook object to Markdown
     """
     return export(MarkdownExporter, nb, **kw)
 
 
 @DocDecorator
 def export_python(nb, **kw):
     """
     Export a notebook object to Python
     """
     return export(PythonExporter, nb, **kw)
 
 
 @DocDecorator
 def export_reveal(nb, **kw):
     """
     Export a notebook object to Reveal
     """
     return export(RevealExporter, nb, **kw)
 
 
 @DocDecorator
 def export_rst(nb, **kw):
     """
     Export a notebook object to RST
     """
     return export(RstExporter, nb, **kw)
 
 
 @DocDecorator
 def export_by_name(format_name, nb, **kw):
     """
     Export a notebook object to a template type by its name.  Reflection
     (Inspect) is used to find the template's corresponding explicit export
     method defined in this module.  That method is then called directly.
     
     format_name : str
         Name of the template style to export to.
     """
     
     function_name = "export_" + format_name.lower()
     
     if function_name in globals():
         return globals()[function_name](nb, **kw)
     else:
         raise ExporterNameError("template for `%s` not found" % function_name)
 
 def get_export_names():
     "Return a list of the currently supported export targets"
     # grab everything after 'export_'
     l = [x[len('export_'):] for x in __all__ if x.startswith('export_')]
     
     # filter out the one method that is not a template
     l = [x for x in l if 'by_name' not in x]
     return sorted(l)

IPython/nbconvert/exporters/exporter.py

@@ -1,361 +1,360
 """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
 import types
 from copy import deepcopy
 
 # other libs/dependencies
 from jinja2 import Environment, FileSystemLoader, ChoiceLoader
 
 # 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, DottedObjectName, Unicode, List, Dict
 from IPython.utils.importstring import import_item
 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': filters.markdown2html,
         '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(
         os.path.join("..", "templates"), config=True,
         help="Path where the template files are located.")
 
     template_skeleton_path = Unicode(
         os.path.join("..", "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)
 
     #Configurability, allows the user to easily add filters and transformers.
     transformers = List(config=True,
         help="""List of transformers, by name or namespace, to enable.""")
     filters = Dict(config=True,
         help="""Dictionary of filters, by name and namespace, to add to the Jinja
         environment.""")
     
     def __init__(self, config=None, extra_loaders=None, **kw):
         """
         Public constructor
     
         Parameters
         ----------
         config : config
             User configuration instance.
         extra_loaders : list[of Jinja Loaders]
             ordered list of Jinja loder to find templates. Will be tried in order
             before the default FileSysteme ones.
         """
         
         #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(extra_loaders=extra_loaders)
 
         #Add transformers
         self._transformers = []
         self._register_transformers()
 
         #Add filters to the Jinja2 environment
         self._register_filters()
 
         #Load user transformers.  Enabled by default.
         if self.transformers:
             for transformer in self.transformers:
-                self.register_transformer(transformer, True)
+                self.register_transformer(transformer, enabled=True)
                 
         #Load user filters.  Overwrite existing filters if need be.
         if self.filters:
             for key, user_filter in self.filters.iteritems():
                 self.register_filter(key, user_filter)
 
 
     @property
     def default_config(self):
         return Config()
 
     
     def from_notebook_node(self, nb, resources=None, **kw):
         """
         Convert a notebook from a notebook node instance.
     
         Parameters
         ----------
         nb : Notebook node
         resources : dict (**kw) 
             of additional resources that can be accessed read/write by 
             transformers and filters.
         """
         nb_copy = deepcopy(nb)
 
+        #Set output extension in resources dict
+        #TODO: init_resources
+        resources['output_extension'] = self.file_extension
+
         #Preprocess
-        nb_copy, resources = self._preprocess(nb_copy, resources)
+        nb_copy, resources = self._transform(nb_copy, resources)
 
         #Convert
         self.template = self.environment.get_template(self.template_file + self.template_extension)
         output = self.template.render(nb=nb_copy, resources=resources)
-
-        #Set output extension in resources dict
-        resources['output_extension'] = self.file_extension
         return output, resources
 
 
-    def from_filename(self, filename, resources=None **kw):
+    def from_filename(self, filename, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
     
         Parameters
         ----------
         filename : str
             Full filename of the notebook file to open and convert.
         """
         
         with io.open(filename) as f:
             return self.from_notebook_node(nbformat.read(f, 'json'), resources=resources,**kw)
 
 
     def from_file(self, file_stream, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
     
         Parameters
         ----------
         file_stream : file-like object
             Notebook file-like object to convert.
         """
         return self.from_notebook_node(nbformat.read(file_stream, 'json'), resources=resources, **kw)
 
 
     def register_transformer(self, transformer, enabled=None):
         """
         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
         """
 
         #Handle transformer's registration based on it's type
         if inspect.isfunction(transformer):
             #Transformer is a function, no need to construct it.
             self._transformers.append(transformer)
             return transformer
 
         elif isinstance(transformer, types.StringTypes):
             #Transformer is a string, import the namespace and recursively call
             #this register_transformer method
             transformer_cls = import_item(DottedObjectName(transformer))
             return self.register_transformer(transformer_cls, enabled=None)
 
         elif isinstance(transformer, MetaHasTraits):
             #Transformer is configurable.  Make sure to pass in new default for 
             #the enabled flag if one was specified.
-            c = Config()
-            if not enabled is None:
-                c = Config({transformer.__name__: {'enabled': enabled}})
-            c.merge(self.config)
-            transformer_instance = transformer(config=c)
+            transformer_instance = transformer(parent=self)
+            if enabled is not None:
+                transformer_instance.enabled = True
 
         else:
             #Transformer is not configurable, construct it
             transformer_instance = transformer()
 
         #Register and return the 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, types.StringTypes):
             filter_cls = import_item(DottedObjectName(filter))
             self.register_filter(name, filter_cls)
         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, disabled
         unless specified explicitly.
         """
 
         self.register_transformer(transformers.coalesce_streams)
         self.register_transformer(transformers.ExtractFigureTransformer)
         
         
     def _register_filters(self):
         """
         Register all of the filters required for the exporter.
         """
         for key, value in default_filters.iteritems():
             self.register_filter(key, value)
         
         
     def _init_environment(self, extra_loaders=None):
         """
         Create the Jinja templating environment.
         """
         here = os.path.dirname(os.path.realpath(__file__))
         loaders = []
         if extra_loaders:
             loaders.extend(extra_loaders)
 
         loaders.append(FileSystemLoader([
                 os.path.join(here, self.template_path),
                 os.path.join(here, self.template_skeleton_path),
                 ]))
 
         self.environment = Environment(
             loader= ChoiceLoader(loaders),
             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):
+    def _transform(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:
             nbc, resc = transformer(nbc, resc)
         return nbc, resc

IPython/nbconvert/exporters/latex.py

@@ -1,111 +1,111
 """
 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
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 import os
 
 # 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(
         os.path.join("..", "templates", "latex"), config=True,
         help="Path where the template files are located.")
 
     template_skeleton_path = Unicode(
         os.path.join("..", "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 ConvertSvgTransformer before any other transformers!  
         #Important because it allows the conversion of svg->png BEFORE the
         #extract figure transformer acts on the data.
         self.register_transformer(transformers.ConvertSvgTransformer, True)
         
         #Register transformers
         super(LatexExporter, self)._register_transformers()
         self.register_transformer(transformers.LatexTransformer, True)
 
     @property
     def default_config(self):
         c = Config({
             'GlobalConfigurable': {
-                'display_data_priority' : ['latex', 'png', 'jpg', 'jpeg', 'text']
+                'display_data_priority' : ['latex', 'png', 'jpg', 'pdf', 'jpeg', 'text']
                 },
              'ExtractFigureTransformer': {
                     'enabled':True
                  }
                  
          })
         c.merge(super(LatexExporter,self).default_config)
         return c
 

IPython/nbconvert/nbconvertapp.py

@@ -1,179 +1,180
 #!/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 os
 import glob
 
 #From IPython
 from IPython.core.application import BaseIPythonApplication
 from IPython.config.application import catch_config_error
 from IPython.utils.traitlets import Unicode, List, Instance, DottedObjectName, Type
 from IPython.utils.importstring import import_item
 
 from .exporters.export import export_by_name, get_export_names, ExporterNameError
 from .exporters.exporter import Exporter
 from .writers.base import WriterBase
 from .utils.config import GlobalConfigurable
 
 #-----------------------------------------------------------------------------
 #Classes and functions
 #-----------------------------------------------------------------------------
 
 class NbConvertApp(BaseIPythonApplication):
     """Application used to convert to and from notebook file type (*.ipynb)"""
 
 
     description = Unicode(
         u"""This application is used to convert notebook files (*.ipynb).
         An ipython config file can be used to batch convert notebooks in the 
         current directory.""")
 
     examples = Unicode(u"""
         Running `ipython nbconvert` will read the directory config file and then 
         apply it to one or more notebooks.
 
         Multiple notebooks can be given at the command line in a couple of 
         different ways:
   
         > ipython nbconvert notebook*.ipynb
         > ipython nbconvert notebook1.ipynb notebook2.ipynb
         > ipython nbconvert # this will use the config file to fill in the notebooks
         """)
     
     config_file_name = Unicode(u'ipython_nbconvert_config.py')
 
     #Writer specific variables
     writer = Instance('IPython.nbconvert.writers.base.WriterBase',  
                       help="""Instance of the writer class used to write the 
                       results of the conversion.""")
     writer_class = DottedObjectName('FilesWriter', config=True, 
                                     help="""Writer class used to write the 
                                     results of the conversion""")
     writer_aliases = {'FilesWriter': 'IPython.nbconvert.writers.files.FilesWriter',
                       'DebugWriter': 'IPython.nbconvert.writers.debug.DebugWriter',
                       'StdoutWriter': 'IPython.nbconvert.writers.stdout.StdoutWriter'}
     writer_factory = Type()
 
     def _writer_class_changed(self, name, old, new):
         if new in self.writer_aliases:
             new = self.writer_aliases[new]
         self.writer_factory = import_item(new)
 
 
     #Other configurable variables
     export_format = Unicode(
         "", config=True,
         help="""If specified, nbconvert will convert the document(s) specified
                 using this format.""")
 
     notebooks = List([], config=True, help="""List of notebooks to convert.
                      Search patterns are supported.""")
 
     aliases = {'format':'NbConvertApp.export_format',
                'notebooks':'NbConvertApp.notebooks',
                'writer':'NbConvertApp.writer_class'} 
 
 
     @catch_config_error
     def initialize(self, argv=None):
         super(NbConvertApp, self).initialize(argv)
 
         #Register class here to have help with help all
         self.classes.insert(0, Exporter)
         self.classes.insert(0, WriterBase)
         self.classes.insert(0, GlobalConfigurable)
 
         #Init
         self.init_config(self.extra_args)
         self.init_writer()
 
 
     def init_config(self, extra_args):
         """
         Add notebooks to the config if needed.  Glob each notebook to replace
         notebook patterns with filenames.
         """
 
         #Get any additional notebook patterns from the commandline
         if len(extra_args) > 0:
             for pattern in extra_args:
                 self.notebooks.append(pattern)
 
         #Use glob to replace all the notebook patterns with filenames.
         filenames = []
         for pattern in self.notebooks:
             for filename in glob.glob(pattern):
                 if not filename in filenames:
                     filenames.append(filename)
         self.notebooks = filenames
 
 
     def init_writer(self):
         """
         Initialize the writer (which is stateless)
         """
         self._writer_class_changed(None, self.writer_class, self.writer_class)
         self.writer = self.writer_factory(parent=self)
 
 
     def start(self, argv=None):
         """
         Entrypoint of NbConvert application.
         """
 
         #Call base
         super(NbConvertApp, self).start()
 
         #Export each notebook
+        #TODO: Empty check
         for notebook_filename in self.notebooks:
 
             #Get a unique key for the notebook and set it in the resources object.
             basename = os.path.basename(notebook_filename)
             notebook_name = basename[:basename.rfind('.')]
             resources = {}
             resources['unique_key'] = notebook_name
 
             #Try to export
             try:
-                return_value = export_by_name(self.export_format,
+                output, resources = export_by_name(self.export_format,
                                               notebook_filename, 
                                               resources=resources,
                                               config=self.config)
             except ExporterNameError as e:
                 print("Error: '%s' exporter not found." % self.export_format,
                       file=sys.stderr)
                 print("Known exporters are:",
                       "\n\t" + "\n\t".join(get_export_names()),
                       file=sys.stderr)
                 sys.exit(-1)
-            else:
-                output, resources = return_value 
+            except Exception as e:
+                print("Error: could no export '%s'" % notebook_filename, file=sys.stderr)
+                print(e, file=sys.stderr)
 
             #Write
             self.writer.write(output, resources, notebook_name=notebook_name)
 
 
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 launch_new_instance = NbConvertApp.launch_instance
-

IPython/nbconvert/transformers/convertfigures.py

@@ -1,74 +1,77
 """Module containing a transformer that converts outputs in the notebook from 
 one format to another.
 """
 #-----------------------------------------------------------------------------
 # 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.
 #-----------------------------------------------------------------------------
 
+#TODO: Come after extract
+
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from .activatable import ActivatableTransformer
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class ConvertFiguresTransformer(ActivatableTransformer):
     """
     Converts all of the outputs in a notebook from one format to another.
     """
 
 
     def __init__(self, from_formats, to_format, **kw):
         """
         Public constructor
         
         Parameters
         ----------
         from_formats : list [of string]
             Formats that the converter can convert from
         to_format : string
             Format that the converter converts to
         config : Config
             Configuration file structure
         **kw : misc
             Additional arguments
         """
         super(ConvertFiguresTransformer, self).__init__(**kw)
 
+        #TODO: Configurable, singular
         self._from_formats = from_formats
         self._to_format = to_format
 
 
     def convert_figure(self, data_format, data):
         raise NotImplementedError()
 
 
     def transform_cell(self, cell, resources, cell_index):
         """
         Apply a transformation on each cell,
         
         See base.py
         """
 
         #Loop through all of the datatypes of the outputs in the cell.
         for index, cell_out in enumerate(cell.get('outputs', [])):
             for data_type, data in cell_out.items():
                 self._convert_figure(cell_out, data_type, data)
         return cell, resources
 
 
     def _convert_figure(self, cell_out, data_type, data):
         """
         Convert a figure and output the results to the cell output
         """
 
         if not self._to_format in cell_out:
             if data_type in self._from_formats:
                 cell_out[self._to_format] = self.convert_figure(data_type, data)

IPython/nbconvert/transformers/convertsvg.py

@@ -1,71 +1,72
 """Module containing a transformer that converts outputs in the notebook from 
 one format to another.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 from IPython.utils.tempdir import TemporaryDirectory
 
 from .convertfigures import ConvertFiguresTransformer
 
 
 #-----------------------------------------------------------------------------
 # Constants
 #-----------------------------------------------------------------------------
 
 INKSCAPE_COMMAND = "inkscape --without-gui --export-pdf=\"{to_filename}\" \"{from_filename}\""
 
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class ConvertSvgTransformer(ConvertFiguresTransformer):
     """
     Converts all of the outputs in a notebook from one format to another.
     """
 
 
     def __init__(self, **kw):
         """
         Constructor
         """
         super(ConvertSvgTransformer, self).__init__(['svg'], 'pdf', **kw)
 
 
     def convert_figure(self, data_format, data):
         """
         Convert a single Svg figure.  Returns converted data.
         """
 
         #Work in a temporary directory
         with TemporaryDirectory() as tmpdir:
             
             #Write fig to temp file
             input_filename = os.path.join(tmpdir, 'figure.' + data_format)
             with open(input_filename, 'w') as f:
                 f.write(data)
 
             #Call conversion application
             output_filename = os.path.join(tmpdir, 'figure.pdf')
             shell = INKSCAPE_COMMAND.format(from_filename=input_filename, 
                                             to_filename=output_filename)
             subprocess.call(shell, shell=True) #Shell=True okay since input is trusted.
 
             #Read output from drive
             if os.path.isfile(output_filename):
                 with open(output_filename, 'rb') as f:
                     return f.read().encode("base64") #PDF is a nb supported binary
                                                      #data type, so base64 encode.
             else:
                 return TypeError("Inkscape svg to png conversion failed")
+#TODO: ERROR: which notebook crashed exporter

IPython/nbconvert/transformers/extractfigure.py

@@ -1,100 +1,91
 """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 sys
 from IPython.utils.traitlets import Dict, Unicode
 from .activatable import ActivatableTransformer
 
 #-----------------------------------------------------------------------------
-# Constants
-#-----------------------------------------------------------------------------
-
-# win64 is win32 for backwards compatability, for now.  See 
-# http://mail.python.org/pipermail/patches/2000-May/000648.html
-# for the original patch that this decision was made.
-WINDOWS_PLATFORMS = ['win32']
-
-#-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class ExtractFigureTransformer(ActivatableTransformer):
     """
     Extracts all of the figures from the notebook file.  The extracted 
     figures are returned in the 'resources' dictionary.
     """
 
 
     figure_filename_template = Unicode(
         "{unique_key}_{cell_index}_{index}.{extension}", config=True)
 
 
     def transform_cell(self, cell, resources, cell_index):
         """
         Apply a transformation on each cell,
         
         Parameters
         ----------
         cell : NotebookNode cell
             Notebook cell being processed
         resources : dictionary
             Additional resources used in the conversion process.  Allows
             transformers to pass variables into the Jinja engine.
         cell_index : int
             Index of the cell being processed (see base.py)
         """
 
         #Get the unique key from the resource dict if it exists.  If it does not 
         #exist, use 'figure' as the default.
         unique_key = resources.get('unique_key', 'figure')
         
         #Make sure figures key exists
         if not 'figures' in resources:
             resources['figures'] = {}
             
         #Loop through all of the outputs in the cell
         for index, out in enumerate(cell.get('outputs', [])):
 
             #Get the output in data formats that the template is interested in.
             for out_type in self.display_data_priority:
                 if out.hasattr(out_type):
                     data = out[out_type]
 
                     #Binary files are base64-encoded, SVG is already XML
                     if out_type in ('png', 'jpg', 'pdf'):
                         data = data.decode('base64')
-                    elif sys.platform in WINDOWS_PLATFORMS:
+                    elif sys.platform == 'win32':
                         data = data.replace('\n', '\r\n').encode("UTF-8")
                     else:
                         data = data.encode("UTF-8")
                     
                     #Build a figure name
                     figure_name = self.figure_filename_template.format( 
                                     unique_key=unique_key,
                                     cell_index=cell_index,
                                     index=index,
                                     extension=out_type)
 
                     #On the cell, make the figure available via 
                     #   cell.outputs[i].svg_filename  ... etc (svg in example)
                     # Where
                     #   cell.outputs[i].svg  contains the data
                     out[out_type + '_filename'] = figure_name
 
                     #In the resources, make the figure available via
                     #   resources['figures']['filename'] = data
                     resources['figures'][figure_name] = data
 
         return cell, resources

IPython/nbconvert/transformers/sphinx.py

@@ -1,261 +1,261
 """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 = {}
-            
+#TODO: Remove draft, and nb            
         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.realpath(os.path.join(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)