Rename SVG2PDFTransformer class

IPython/nbconvert/nbconvertapp.py.orig

@@ -0,0 +1,203 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 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.base import NbConvertBase
+
+#-----------------------------------------------------------------------------
+#Classes and functions
+#-----------------------------------------------------------------------------
+
+class NbConvertApp(BaseIPythonApplication):
+    """Application used to convert to and from notebook file type (*.ipynb)"""
+
+<<<<<<< HEAD
+    name = 'ipython-nbconvert'
+=======
+    name = Unicode(u'ipython-nbconvert')
+    
+    config_file_name = Unicode(u'ipython_nbconvert_config.py')
+>>>>>>> Moved config_file_name up
+
+    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
+        """)
+    
+    #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.""")
+
+    nbconvert_aliases = {'format':'NbConvertApp.export_format',
+               'notebooks':'NbConvertApp.notebooks',
+               'writer':'NbConvertApp.writer_class'} 
+
+
+    @catch_config_error
+    def initialize(self, argv=None):
+        self.aliases.update(self.nbconvert_aliases)
+
+        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, NbConvertBase)
+
+        #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):
+        """
+        Ran after initiialization completed
+        """
+        super(NbConvertApp, self).start()
+        self.convert_notebooks()
+
+
+    def convert_notebooks(self):
+        """
+        Convert the notebooks in the self.notebook traitlet
+        """
+        #Export each notebook
+        conversion_success = 0
+        for notebook_filename in self.notebooks:
+
+            #Get a unique key for the notebook and set it in the resources object.
+            basename = os.path.basename(notebook_filename)
+            notebook_name = basename[:basename.rfind('.')]
+            resources = {}
+            resources['unique_key'] = notebook_name
+
+            #Try to export
+            try:
+                output, resources = export_by_name(self.export_format,
+                                              notebook_filename, 
+                                              resources=resources,
+                                              config=self.config)
+            except ExporterNameError as e:
+                print("Error: '%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)
+            #except Exception as e:
+                #print("Error: could not export '%s'" % notebook_filename, file=sys.stderr)
+                #print(e, file=sys.stderr)
+            else:
+                self.writer.write(output, resources, notebook_name=notebook_name)
+                conversion_success += 1
+
+        #If nothing was converted successfully, help the user.
+        if conversion_success == 0:
+
+            #No notebooks were specified, show help.
+            if len(self.notebooks) == 0:
+                self.print_help()
+
+            #Notebooks were specified, but not converted successfully.  Show how
+            #to access help.
+            else:
+                print('For help, use "ipython nbconvert --help"')
+
+
+#-----------------------------------------------------------------------------
+# Main entry point
+#-----------------------------------------------------------------------------
+
+launch_new_instance = NbConvertApp.launch_instance

IPython/nbconvert/exporters/latex.py

@@ -1,110 +1,110 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
 #-----------------------------------------------------------------------------
 
 # Stdlib imports
 import os
 
 # IPython imports
 from IPython.utils.traitlets import Unicode, List
 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)
 
     default_transformers = List([transformers.ExtractFigureTransformer,
                                  transformers.CSSHTMLHeaderTransformer,
                                  transformers.LatexTransformer,
-                                 transformers.Svg2PdfTransformer],
+                                 transformers.SVG2PDFTransformer],
         config=True,
         help="""List of transformers available by default, by name, namespace, 
         instance, or type.""")
 
 
     def _init_filters(self):
         """
         Register all of the filters required for the exporter.
         """
         
         #Register the filters of the base class.
         super(LatexExporter, self)._init_filters()
 
         #Add latex filters to the Jinja2 environment
         self.register_filter('escape_tex', filters.escape_latex) 
         self.register_filter('highlight', filters.highlight2latex) 
     
 
     @property
     def default_config(self):
         c = Config({
             'NbConvertBase': {
                 'display_data_priority' : ['latex', 'png', 'jpg', 'svg', 'jpeg', 'text']
                 },
              'ExtractFigureTransformer': {
                     'enabled':True
                  },
-             'Svg2PdfTransformer': {
+             'SVG2PDFTransformer': {
                     'enabled':True
                  },
              'LatexTransformer': {
                     'enabled':True
                  }
          })
         c.merge(super(LatexExporter,self).default_config)
         return c

IPython/nbconvert/transformers/SVG2PDF.py

@@ -1,77 +1,77 b''
 """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
 import sys
 import subprocess
 
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.utils.traitlets import Unicode
 
 from .convertfigures import ConvertFiguresTransformer
 
 
 #-----------------------------------------------------------------------------
 # Constants
 #-----------------------------------------------------------------------------
 
 INKSCAPE_COMMAND = 'inkscape --without-gui --export-pdf="{to_filename}" "{from_filename}"'
 INKSCAPE_OSX_COMMAND = '/Applications/Inkscape.app/Contents/Resources/bin/inkscape --without-gui --export-pdf="{to_filename}" "{from_filename}"'
 
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
-class Svg2PdfTransformer(ConvertFiguresTransformer):
+class SVG2PDFTransformer(ConvertFiguresTransformer):
     """
     Converts all of the outputs in a notebook from one format to another.
     """
 
     from_format = Unicode('svg', config=True, help='Format the converter accepts')
     to_format = Unicode('pdf', config=False, help='Format the converter writes')
 
 
     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)
 
             #Determine command (different on Mac OSX)
             command = INKSCAPE_COMMAND 
             if sys.platform == 'darwin':
                 command = INKSCAPE_OSX_COMMAND
 
             #Call conversion application
             output_filename = os.path.join(tmpdir, 'figure.pdf')
             shell = 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")

IPython/nbconvert/transformers/__init__.py

@@ -1,12 +1,12 b''
 # Class base Transformers
 from .base import ConfigurableTransformer
 from .convertfigures import ConvertFiguresTransformer
-from .SVG2PDF import Svg2PdfTransformer
+from .SVG2PDF import SVG2PDFTransformer
 from .extractfigure import ExtractFigureTransformer
 from .revealhelp import RevealHelpTransformer
 from .latex import LatexTransformer
 from .sphinx import SphinxTransformer
 from .csshtmlheader import CSSHTMLHeaderTransformer
 
 # decorated function Transformers
 from .coalescestreams import coalesce_streams