nbconvert is now configurable app

converters/base.py

@@ -1,411 +1,411 b''
 """Base classes for the notebook conversion pipeline.
 
 This module defines Converter, from which all objects designed to implement
 a conversion of IPython notebooks to some other format should inherit.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2012, 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 codecs
 import io
 import logging
 import os
 import pprint
 import re
 from types import FunctionType
 
 # IPython imports
 from IPython.nbformat import current as nbformat
 
 # Our own imports
 from .utils import remove_fake_files_url
 
 
 #-----------------------------------------------------------------------------
 # Local utilities
 #-----------------------------------------------------------------------------
 
 def clean_filename(filename):
     """
     Remove non-alphanumeric characters from filenames.
 
     Parameters
     ----------
     filename : str
         The filename to be sanitized.
 
     Returns
     -------
     clean : str
         A sanitized filename that contains only alphanumeric
         characters and underscores.
     """
     filename = re.sub(r'[^a-zA-Z0-9_]', '_', filename)
     return filename
 
 
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
 
 class ConversionException(Exception):
     pass
 
 
 class DocStringInheritor(type):
     """
     This metaclass will walk the list of bases until the desired
     superclass method is found AND if that method has a docstring and only
     THEN does it attach the superdocstring to the derived class method.
 
     Please use carefully, I just did the metaclass thing by following
     Michael Foord's Metaclass tutorial
     (http://www.voidspace.org.uk/python/articles/metaclasses.shtml), I may
     have missed a step or two.
 
     source:
     http://groups.google.com/group/comp.lang.python/msg/26f7b4fcb4d66c95
     by Paul McGuire
     """
     def __new__(meta, classname, bases, classDict):
         newClassDict = {}
         for attributeName, attribute in classDict.items():
             if type(attribute) == FunctionType:
                 # look through bases for matching function by name
                 for baseclass in bases:
                     if hasattr(baseclass, attributeName):
                         basefn = getattr(baseclass, attributeName)
                         if basefn.__doc__:
                             attribute.__doc__ = basefn.__doc__
                             break
             newClassDict[attributeName] = attribute
         return type.__new__(meta, classname, bases, newClassDict)
 
 
 class Converter(object):
     __metaclass__ = DocStringInheritor
     #-------------------------------------------------------------------------
     # Class-level attributes determining the behaviour of the class but
     # probably not varying from instance to instance.
     #-------------------------------------------------------------------------
     default_encoding = 'utf-8'
     extension = str()
     blank_symbol = " "
     # Which display data format is best? Subclasses can override if
     # they have specific requirements.
     display_data_priority = ['pdf', 'svg', 'png', 'jpg', 'text']
     #-------------------------------------------------------------------------
     # Instance-level attributes that are set in the constructor for this
     # class.
     #-------------------------------------------------------------------------
     infile = str()
     highlight_source = True
     infile_dir = str()
     infile_root = str()
     clean_name = str()
     files_dir = str()
     outbase = str()
     #-------------------------------------------------------------------------
     # Instance-level attributes that are set by other methods in the base
     # class.
     #-------------------------------------------------------------------------
     figures_counter = 0
     output = unicode()
     #-------------------------------------------------------------------------
     # Instance-level attributes that are not actually mentioned further
     # in this class. TODO: Could they be usefully moved to a subclass?
     #-------------------------------------------------------------------------
     with_preamble = True
     user_preamble = None
     raw_as_verbatim = False
 
-    def __init__(self, infile, highlight_source=True, exclude=[]):
+    def __init__(self, infile, highlight_source=True, exclude=[],  **kw):
         # N.B. Initialized in the same order as defined above. Please try to
         # keep in this way for readability's sake.
         self.exclude_cells = exclude
         self.infile = infile
         self.highlight_source = highlight_source
         self.infile_dir, infile_root = os.path.split(infile)
         self.infile_root = os.path.splitext(infile_root)[0]
         self.clean_name = clean_filename(self.infile_root)
         # Handle the creation of a directory for ancillary files, for
         # formats that need one.
         files_dir = os.path.join(self.infile_dir, self.clean_name + '_files')
         if not os.path.isdir(files_dir):
             os.mkdir(files_dir)
         self.files_dir = files_dir
         self.outbase = os.path.join(self.infile_dir, self.infile_root)
 
     def __del__(self):
         if os.path.isdir(self.files_dir) and not os.listdir(self.files_dir):
             os.rmdir(self.files_dir)
 
     def _get_prompt_number(self, cell):
         return cell.prompt_number if hasattr(cell, 'prompt_number') \
             else self.blank_symbol
 
     def dispatch(self, cell_type):
         """return cell_type dependent render method,  for example render_code
         """
         return getattr(self, 'render_' + cell_type, self.render_unknown)
 
     def dispatch_display_format(self, format):
         """
         return output_type dependent render method,  for example
         render_output_text
         """
         return getattr(self, 'render_display_format_' + format,
                        self.render_unknown_display)
 
     def convert(self, cell_separator='\n'):
         """
         Generic method to converts notebook to a string representation.
 
         This is accomplished by dispatching on the cell_type, so subclasses of
         Convereter class do not need to re-implement this method, but just
         need implementation for the methods that will be dispatched.
 
         Parameters
         ----------
         cell_separator : string
           Character or string to join cells with. Default is "\n"
 
         Returns
         -------
         out : string
         """
         lines = []
         lines.extend(self.optional_header())
         lines.extend(self.main_body(cell_separator))
         lines.extend(self.optional_footer())
         return u'\n'.join(lines)
 
     def main_body(self, cell_separator='\n'):
         converted_cells = []
         for worksheet in self.nb.worksheets:
             for cell in worksheet.cells:
                 #print(cell.cell_type)  # dbg
                 conv_fn = self.dispatch(cell.cell_type)
                 if cell.cell_type in ('markdown', 'raw'):
                     remove_fake_files_url(cell)
                 converted_cells.append('\n'.join(conv_fn(cell)))
         cell_lines = cell_separator.join(converted_cells).split('\n')
         return cell_lines
 
     def render(self):
         "read, convert, and save self.infile"
         if not hasattr(self, 'nb'):
             self.read()
         self.output = self.convert()
         assert(type(self.output) == unicode)
         return self.save()
 
     def read(self):
         "read and parse notebook into NotebookNode called self.nb"
         with open(self.infile) as f:
             self.nb = nbformat.read(f, 'json')
 
     def save(self, outfile=None, encoding=None):
         "read and parse notebook into self.nb"
         if outfile is None:
             outfile = self.outbase + '.' + self.extension
         if encoding is None:
             encoding = self.default_encoding
         with io.open(outfile, 'w', encoding=encoding) as f:
             f.write(self.output)
         return os.path.abspath(outfile)
 
     def optional_header(self):
         """
         Optional header to insert at the top of the converted notebook
 
         Returns a list
         """
         return []
 
     def optional_footer(self):
         """
         Optional footer to insert at the end of the converted notebook
 
         Returns a list
         """
         return []
 
     def _new_figure(self, data, fmt):
         """Create a new figure file in the given format.
 
         Returns a path relative to the input file.
         """
         figname = '%s_fig_%02i.%s' % (self.clean_name,
                                       self.figures_counter, fmt)
         self.figures_counter += 1
         fullname = os.path.join(self.files_dir, figname)
 
         # Binary files are base64-encoded, SVG is already XML
         if fmt in ('png', 'jpg', 'pdf'):
             data = data.decode('base64')
             fopen = lambda fname: open(fname, 'wb')
         else:
             fopen = lambda fname: codecs.open(fname, 'wb',
                                               self.default_encoding)
 
         with fopen(fullname) as f:
             f.write(data)
 
         return fullname
 
     def render_heading(self, cell):
         """convert a heading cell
 
         Returns list."""
         raise NotImplementedError
 
     def render_code(self, cell):
         """Convert a code cell
 
         Returns list."""
         raise NotImplementedError
 
     def render_markdown(self, cell):
         """convert a markdown cell
 
         Returns list."""
         raise NotImplementedError
 
     def _img_lines(self, img_file):
         """Return list of lines to include an image file."""
         # Note: subclasses may choose to implement format-specific _FMT_lines
         # methods if they so choose (FMT in {png, svg, jpg, pdf}).
         raise NotImplementedError
 
     def render_display_data(self, output):
         """convert display data from the output of a code cell
 
         Returns list.
         """
         for fmt in self.display_data_priority:
             if fmt in output:
                 break
         else:
             for fmt in output:
                 if fmt != 'output_type':
                     break
             else:
                 raise RuntimeError('no display data')
 
         # Is it an image?
         if fmt in ['png', 'svg', 'jpg', 'pdf']:
             img_file = self._new_figure(output[fmt], fmt)
             # Subclasses can have format-specific render functions (e.g.,
             # latex has to auto-convert all SVG to PDF first).
             lines_fun = getattr(self, '_%s_lines' % fmt, None)
             if not lines_fun:
                 lines_fun = self._img_lines
             lines = lines_fun(img_file)
         else:
             lines_fun = self.dispatch_display_format(fmt)
             lines = lines_fun(output)
 
         return lines
 
     def render_raw(self, cell):
         """convert a cell with raw text
 
         Returns list."""
         raise NotImplementedError
 
     def render_unknown(self, cell):
         """Render cells of unkown type
 
         Returns list."""
         data = pprint.pformat(cell)
         logging.warning('Unknown cell: %s' % cell.cell_type)
         return self._unknown_lines(data)
 
     def render_unknown_display(self, output, type):
         """Render cells of unkown type
 
         Returns list."""
         data = pprint.pformat(output)
         logging.warning('Unknown output: %s' % output.output_type)
         return self._unknown_lines(data)
 
     def render_stream(self, output):
         """render the stream part of an output
 
         Returns list.
 
         Identical to render_display_format_text
         """
         return self.render_display_format_text(output)
 
     def render_pyout(self, output):
         """convert pyout part of a code cell
 
         Returns list."""
         raise NotImplementedError
 
     def render_pyerr(self, output):
         """convert pyerr part of a code cell
 
         Returns list."""
         raise NotImplementedError
 
     def _unknown_lines(self, data):
         """Return list of lines for an unknown cell.
 
         Parameters
         ----------
         data : str
           The content of the unknown data as a single string.
         """
         raise NotImplementedError
 
     # These are the possible format types in an output node
 
     def render_display_format_text(self, output):
         """render the text part of an output
 
         Returns list.
         """
         raise NotImplementedError
 
     def render_display_format_html(self, output):
         """render the html part of an output
 
         Returns list.
         """
         raise NotImplementedError
 
     def render_display_format_latex(self, output):
         """render the latex part of an output
 
         Returns list.
         """
         raise NotImplementedError
 
     def render_display_format_json(self, output):
         """render the json part of an output
 
         Returns list.
         """
         raise NotImplementedError
 
     def render_display_format_javascript(self, output):
         """render the javascript part of an output
 
         Returns list.
         """
         raise NotImplementedError

nbconvert.py

@@ -1,87 +1,145 b''
 #!/usr/bin/env python
 """Convert IPython notebooks to other formats, such as ReST, and HTML.
 
 Example:
   ./nbconvert.py --format rst file.ipynb
 
 Produces 'file.rst', along with auto-generated figure files
 called nb_figure_NN.png.
 """
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 # From IPython
 from IPython.external import argparse
 
+# All the stuff needed for the configurable things
+from IPython.config.application import Application, catch_config_error
+from IPython.config.configurable import Configurable
+from IPython.config.loader import Config, ConfigFileNotFound
+from IPython.utils.traitlets import List, Unicode, Type, Bool, Dict, CaselessStrEnum
+
+
 # local
 from converters.html import ConverterHTML
 from converters.markdown import ConverterMarkdown
 from converters.bloggerhtml import ConverterBloggerHTML
 from converters.rst import ConverterRST
 from converters.latex import ConverterLaTeX
 from converters.python import ConverterPy
 
 
 # When adding a new format, make sure to add it to the `converters`
 # dictionary below. This is used to create the list of known formats,
 # which gets printed in case an unknown format is encounteres, as well
 # as in the help
 
 converters = {
     'rst': ConverterRST,
     'markdown': ConverterMarkdown,
     'html': ConverterHTML,
     'blogger-html': ConverterBloggerHTML,
     'latex': ConverterLaTeX,
     'py': ConverterPy,
     }
 
 default_format = 'rst'
 
 # Extract the list of known formats and mark the first format as the default.
 known_formats = ', '.join([key + " (default)" if key == default_format else key
                            for key in converters])
 
+class NbconvertApp(Application):
 
-def main(infile, format='rst', preamble=None, exclude=[],
-         highlight_source=True):
-    """Convert a notebook to html in one step"""
-    try:
-        ConverterClass = converters[format]
-    except KeyError:
-        raise SystemExit("Unknown format '%s', " % format +
-                         "known formats are: " + known_formats)
+    name = Unicode('thisIsNbconvertApp',config=True)
+
+    fmt = CaselessStrEnum(converters.keys(),
+                          default_value='rst', 
+                          config=True,
+                          help="Supported conversion format")
+
+    preamble = Unicode("" ,
+                        config=True,
+                        help="Path to a user-specified preamble file")
+
+    highlight = Bool(True, 
+                     config=True,
+                     help="Enable syntax highlighting for code blocks.")
+
+    exclude = List( [],
+                    config=True,
+                    help = 'list of cells to exclude while converting')
+
+    infile = Unicode("", config=True)
 
     converter = ConverterClass(infile, highlight_source=highlight_source, exclude=exclude)
     converter.render()
 
+
+    aliases = {
+            'format':'NbconvertApp.fmt',
+            'highlight':'NbconvertApp.highlight',
+            'preamble':'NbconvertApp.preamble',
+            'infile' : 'NbconvertApp.infile'
+            }
+
+    def __init__(self, **kwargs):
+        super(NbconvertApp, self).__init__(**kwargs)
+
+    def initialize(self, argv=None):
+        # don't hook up crash handler before parsing command-line
+        self.parse_command_line(argv)
+        cl_config = self.config
+        print(self.config)
+        self.update_config(cl_config)
+        #self.init_crash_handler()
+        #self.foo = Cnf(config=self.config)
+        #if self.subapp is not None:
+            # stop here if subapp is taking over
+            #return
+        #cl_config = self.config
+        #self.init_profile_dir()
+        #self.init_config_files()
+        #self.load_config_file()
+        # enforce cl-opts override configfile opts:
+        #self.update_config(cl_config)
+
+
+    def run(self):
+        """Convert a notebook to html in one step"""
+        ConverterClass = converters[self.fmt]
+
+        converter = ConverterClass(self.infile, highlight_source=self.highlight, preamble=self.preamble, exclude=self.exclude)
+        converter.render()
+
+def main():
+    """Convert a notebook to html in one step"""
+    app = NbconvertApp.instance()
+    print(app.classes)
+    app.initialize()
+    app.start()
+    app.run()
 #-----------------------------------------------------------------------------
 # Script main
 #-----------------------------------------------------------------------------
 
 if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description=__doc__,
-            formatter_class=argparse.RawTextHelpFormatter)
+    #parser = argparse.ArgumentParser(description=__doc__,
+    #        formatter_class=argparse.RawTextHelpFormatter)
     # TODO: consider passing file like object around, rather than filenames
     # would allow us to process stdin, or even http streams
     #parser.add_argument('infile', nargs='?', type=argparse.FileType('r'),
     #                    default=sys.stdin)
 
     #Require a filename as a positional argument
-    parser.add_argument('infile', nargs=1)
-    parser.add_argument('-f', '--format', default='rst',
-                        help='Output format. Supported formats: \n' +
-                        known_formats)
-    parser.add_argument('-p', '--preamble',
-                        help='Path to a user-specified preamble file')
-    parser.add_argument('-e', '--exclude', default='',
-                        help='Comma-separated list of cells to exclude')
-    parser.add_argument('-H', '--no-highlighting', action='store_false',
-                        help='Disable syntax highlighting for code blocks.')
-    args = parser.parse_args()
-    exclude_cells = [s.strip() for s in args.exclude.split(',')]
-
-    main(infile=args.infile[0], format=args.format, preamble=args.preamble,
-         exclude=exclude_cells, highlight_source=args.no_highlighting)
+    #parser.add_argument('infile', nargs=1)
+    #parser.add_argument('-e', '--exclude', default='',
+    #                    help='Comma-separated list of cells to exclude')
+    #parser.add_argument('-H', '--no-highlighting', action='store_false',
+    #                    help='Disable syntax highlighting for code blocks.')
+    #args = parser.parse_args()
+    #exclude_cells = [s.strip() for s in args.exclude.split(',')]
+
+    main()