nbconvert is now configurable app

converters/base.py

@@ -131,7 +131,7 b' class Converter(object):'
     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

nbconvert.py

@@ -15,6 +15,13 b' 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
@@ -44,44 +51,95 b" default_format = 'rst'"
 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()