Transformer refactor

COPYING.txt

@@ -0,0 +1,3 b''
+See COPYING.txt distributed with iPython.
+
+#TODO, give NBCONVERT its own license
  No newline at end of file

transformers/activatable.py

@@ -0,0 +1,1 b''
+ 

transformers/csshtmlheader.py

@@ -0,0 +1,1 b''
+ 

transformers/extractfigure.py

@@ -0,0 +1,1 b''
+ 

transformers/reavealhelp.py

@@ -0,0 +1,1 b''
+ 

utils/datatypefilter.py

@@ -0,0 +1,31 b''
+"""Filter used to select the first prefered output format available.
+
+The filter contained in the file allows the converter templates to select
+the output format that is most valuable to the active export format.  The
+value of the different formats is set via 
+GlobalConfigurable.display_data_priority
+"""
+#-----------------------------------------------------------------------------
+# Copyright (c) 2013, the IPython Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+class DataTypeFilter(GlobalConfigurable):
+    """ Returns the prefered display format """
+
+    def __init__(self, config=None, **kw):
+        super(FilterDataType, self).__init__(config=config, **kw)
+
+    def __call__(self, output):
+        """ Return the first available format in the priority """
+
+        for fmt in self.display_data_priority:
+            if fmt in output:
+                return [fmt]
+        return []
  No newline at end of file

utils/markdown.py

@@ -0,0 +1,75 b''
+"""Markdown utilities
+
+This file contains a collection of utility functions for dealing with 
+markdown.
+"""
+#-----------------------------------------------------------------------------
+# Copyright (c) 2013, the IPython Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+from __future__ import print_function
+
+# Stdlib imports
+import subprocess
+
+#-----------------------------------------------------------------------------
+# Functions
+#-----------------------------------------------------------------------------
+# Pandoc-dependent code
+def markdown2latex(src):
+    """Convert a markdown string to LaTeX via pandoc.
+
+    This function will raise an error if pandoc is not installed.
+
+    Any error messages generated by pandoc are printed to stderr.
+
+    Parameters
+    ----------
+    src : string
+      Input string, assumed to be valid markdown.
+
+    Returns
+    -------
+    out : string
+      Output as returned by pandoc.
+    """
+    p = subprocess.Popen('pandoc -f markdown -t latex'.split(),
+                         stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+    out, err = p.communicate(src.encode('utf-8'))
+    if err:
+        print(err, file=sys.stderr)
+    #print('*'*20+'\n', out, '\n'+'*'*20)  # dbg
+    return unicode(out, 'utf-8')
+
+
+def markdown2rst(src):
+    """Convert a markdown string to LaTeX via pandoc.
+
+    This function will raise an error if pandoc is not installed.
+
+    Any error messages generated by pandoc are printed to stderr.
+
+    Parameters
+    ----------
+    src : string
+      Input string, assumed to be valid markdown.
+
+    Returns
+    -------
+    out : string
+      Output as returned by pandoc.
+    """
+    p = subprocess.Popen('pandoc -f markdown -t rst'.split(),
+                         stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+    out, err = p.communicate(src.encode('utf-8'))
+    if err:
+        print(err, file=sys.stderr)
+    #print('*'*20+'\n', out, '\n'+'*'*20)  # dbg
+    return unicode(out, 'utf-8')
  No newline at end of file

api/exporter.py

@@ -1,387 +1,381 b''
 """Exporter for the notebook conversion pipeline.
 
 This module defines Exporter, a highly configurable converter
 that uses Jinja2 to export notebook files into different format.
 
 You can register both pre-transformers that will act on the notebook format
 befor conversion and jinja filter that would then be availlable in the templates
 """
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function, absolute_import
 
 # Stdlib imports
 import io
 import os
 import re
 
 # IPython imports
 from IPython.config.configurable import Configurable
 from IPython.nbformat import current as nbformat
 from IPython.utils.traitlets import MetaHasTraits, Unicode, List, Bool
 from IPython.utils.text import indent
 
 # other libs/dependencies
 from jinja2 import Environment, FileSystemLoader
 from markdown import markdown
 
 # local import (pre-transformers)
 from exceptions import ConversionException
 from . import transformers as trans #TODO
-from .latex_transformer import (LatexTransformer) #TODO
-from .utils import  markdown2rst #TODO
-from .utils import markdown2latex #TODO
 from .utils import highlight2latex #TODO
 from .utils import get_lines #TODO
 from .utils import remove_ansi #TODO
 from .utils import highlight, ansi2html #TODO
-from .latex_transformer import rm_math_space #TODO
-import .utils.strings as strings
 
-#Jinja2 filters
-from .jinja_filters import (python_comment,
-    rm_fake,   
-     escape_tex, FilterDataType,
-    rm_dollars
-    )
+from .transformers.latex import LatexTransformer, rm_math_space
+
+import .utils.strings as strings
+import .utils.markdown as markdown_utils
+import .utils.datatypefilter.DataTypeFilter as DataTypeFilter
 
 #Try to import the Sphinx exporter.  If the user doesn't have Sphinx isntalled 
 #on his/her machine, fail silently.
 try:
     from .sphinx_transformer import (SphinxTransformer) #TODO
 except ImportError:
     SphinxTransformer = None
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
 
 #Standard Jinja2 environment constants
 TEMPLATE_PATH = "/../templates/"
 TEMPLATE_SKELETON_PATH = "/../templates/skeleton/"
 TEMPLATE_EXTENSION = ".tpl"
 
 #Latex Jinja2 constants
 LATEX_TEMPLATE_PATH = "/../templates/tex/"
 LATEX_TEMPLATE_SKELETON_PATH = "/../templates/tex/skeleton/"
 LATEX_TEMPLATE_EXTENSION = ".tplx"
 
 #Special Jinja2 syntax that will not conflict when exporting latex.
 LATEX_JINJA_COMMENT_BLOCK = ["((=", "=))"]
 LATEX_JINJA_VARIABLE_BLOCK = ["(((", ")))"]
 LATEX_JINJA_LOGIC_BLOCK = ["((*", "*))"]
 
 #Jinja2 extensions to load.
 JINJA_EXTENSIONS = ['jinja2.ext.loopcontrols']
 
 #Latex substitutions for escaping latex.
 LATEX_SUBS = (
     (re.compile(r'\\'), r'\\textbackslash'),
     (re.compile(r'([{}_#%&$])'), r'\\\1'),
     (re.compile(r'~'), r'\~{}'),
     (re.compile(r'\^'), r'\^{}'),
     (re.compile(r'"'), r"''"),
     (re.compile(r'\.\.\.+'), r'\\ldots'),
 )
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 class Exporter(Configurable):
     """ A Jinja2 base converter templates
 
     Preprocess the ipynb files, feed it throug jinja templates,
     and spit an converted files and a data object with other data
     should be mostly configurable
     """
 
     pre_transformer_order = List(['haspyout_transformer'],
         config=True,
         help= """
             An ordered list of pre transformer to apply to the ipynb
             file before running through templates
             """
         )
 
     tex_environement = Bool(
         False,
         config=True,
         help=" Whether or not the user is exporting to latex.")
 
     template_file = Unicode(
             '', config=True,
             help="Name of the template file to use")
 
     fileext = Unicode(
         'txt', config=True, 
         help="Extension of the file that should be written to disk"
         )
 
     stdout = Bool(
         True, config=True,
         help="""Whether to print the converted ipynb file to stdout
         "use full do diff files without actually writing a new file"""
         )
 
     write = Bool(
         False, config=True,
         help="""Should the converted notebook file be written to disk
         along with potential extracted resources."""
         )
 
     #Processors that process the input data prior to the export, set in the 
     #constructor for this class.
     preprocessors = [] 
 
     def __init__(self, preprocessors={}, jinja_filters={}, config=None, export_format, **kw):
         """ Init a new converter.
 
         config: the Configurable config object to pass around.
 
         preprocessors: dict of **availlable** key/value function to run on
                        ipynb json data before conversion to extract/inline file.
                        See `transformer.py` and `ConfigurableTransformers`
 
                        set the order in which the transformers should apply
                        with the `pre_transformer_order` trait of this class
 
                        transformers registerd by this key will take precedence on
                        default one.
 
         jinja_filters: dict of supplementary jinja filter that should be made
                        availlable in template. If those are of Configurable Class type,
                        they will be instanciated with the config object as argument.
 
                        user defined filter will overwrite the one availlable by default.
         """
 
         #Merge default config options with user specific override options.
         default_config = self._get_default_options()
         if not config == None:
             default_config._merge(config)
         config = default_config
 
         #Call the base class constructor
         super(Exporter, self).__init__(config=config, **kw)
 
         #Create a Latex environment if the user is exporting latex.
         if self.tex_environement:
             self.ext = LATEX_TEMPLATE_EXTENSION
             self.env = Environment(
                 loader=FileSystemLoader([
                     os.path.dirname(os.path.realpath(__file__)) + LATEX_TEMPLATE_PATH,
                     os.path.dirname(os.path.realpath(__file__)) + LATEX_TEMPLATE_SKELETON_PATH,
                     ]),
                 extensions=JINJA_EXTENSIONS
                 )
 
             #Set special Jinja2 syntax that will not conflict with latex.
             self.env.block_start_string = LATEX_JINJA_LOGIC_BLOCK[0]
             self.env.block_end_string = LATEX_JINJA_LOGIC_BLOCK[1]
             self.env.variable_start_string = LATEX_JINJA_VARIABLE_BLOCK[0]
             self.env.variable_end_string = LATEX_JINJA_VARIABLE_BLOCK[1]
             self.env.comment_start_string = LATEX_JINJA_COMMENT_BLOCK[0]
             self.env.comment_end_string = LATEX_JINJA_COMMENT_BLOCK[1]
 
         else: #Standard environment
             self.ext = TEMPLATE_EXTENSION
             self.env = Environment(
                 loader=FileSystemLoader([
                     os.path.dirname(os.path.realpath(__file__)) + TEMPLATE_PATH,
                     os.path.dirname(os.path.realpath(__file__)) + TEMPLATE_SKELETON_PATH,
                     ]),
                 extensions=JINJA_EXTENSIONS
                 )
 
         for name in self.pre_transformer_order:
             # get the user-defined transformer first
             transformer = preprocessors.get(name, getattr(trans, name, None))
             if isinstance(transformer, MetaHasTraits):
                 transformer = transformer(config=config)
             self.preprocessors.append(transformer)
 
         #For compatibility, TODO: remove later.
         self.preprocessors.append(trans.coalesce_streams)
         self.preprocessors.append(trans.ExtractFigureTransformer(config=config))
         self.preprocessors.append(trans.RevealHelpTransformer(config=config))
         self.preprocessors.append(trans.CSSHtmlHeaderTransformer(config=config))
         self.preprocessors.append(LatexTransformer(config=config))
 
         #Only load the sphinx transformer if the file reference worked 
         #(Sphinx dependencies exist on the user's machine.)
         if SphinxTransformer:
             self.preprocessors.append(SphinxTransformer(config=config))
 
         #Add filters to the Jinja2 environment
-        self.env.filters['filter_data_type'] = FilterDataType(config=config)
+        self.env.filters['filter_data_type'] = DataTypeFilter(config=config)
         self.env.filters['pycomment'] = _python_comment
         self.env.filters['indent'] = indent
         self.env.filters['rm_fake'] = _rm_fake
         self.env.filters['rm_ansi'] = remove_ansi
         self.env.filters['markdown'] = markdown
         self.env.filters['ansi2html'] = ansi2html
-        self.env.filters['markdown2latex'] = markdown2latex
-        self.env.filters['markdown2rst'] = markdown2rst
+        self.env.filters['markdown2latex'] = markdown_utils.markdown2latex
+        self.env.filters['markdown2rst'] = markdown_utils.markdown2rst
         self.env.filters['get_lines'] = get_lines
         self.env.filters['wrap'] = strings.wrap
         self.env.filters['rm_dollars'] = strings.strip_dollars
         self.env.filters['rm_math_space'] = rm_math_space
         self.env.filters['highlight2html'] = highlight 
         self.env.filters['highlight2latex'] = highlight2latex
 
         #Latex specific filters
         if self.tex_environement:
             self.env.filters['escape_tex'] = _escape_tex 
             self.env.filters['highlight'] = highlight2latex 
         else:
             self.env.filters['highlight'] = highlight 
 
         #Load user filters.  Overwrite existing filters if need be.
         for key, user_filter in jinja_filters.iteritems():
             if isinstance(user_filter, MetaHasTraits):
                 self.env.filters[key] = user_filter(config=config)
             else:
                 self.env.filters[key] = user_filter
 
         #Load the template file.
         self.template = self.env.get_template(self.template_file+self.ext)
 
 
     def export(self, nb):
         """Export notebook object
 
         nb: Notebook object to export.
 
         Returns both the converted ipynb file and a dict containing the
         resources created along the way via the transformers and Jinja2
         processing.
         """
 
         nb, resources = self._preprocess(nb)
         return self.template.render(nb=nb, resources=resources), resources
 
 
     def from_filename(self, filename):
         """Read and export a notebook from a filename
 
         filename: Filename of the notebook file to export.
 
         Returns both the converted ipynb file and a dict containing the
         resources created along the way via the transformers and Jinja2
         processing.
         """
         with io.open(filename) as f:
             return self.export(nbformat.read(f, 'json'))
 
 
     def from_file(self, file_stream):
         """Read and export a notebook from a filename
 
         file_stream: File handle of file that contains notebook data.
 
         Returns both the converted ipynb file and a dict containing the
         resources created along the way via the transformers and Jinja2
         processing.
         """
 
         return self.export(nbformat.read(file_stream, 'json'))
 
 
     def _preprocess(self, nb):
         """ Preprocess the notebook using the transformers specific
         for the current export format.
 
         nb: Notebook to preprocess
         """
 
         #Dict of 'resources' that can be filled by the preprocessors.
         resources = {}
 
         #Run each transformer on the notebook.  Carry the output along
         #to each transformer
         for transformer in self.preprocessors:
             nb, resources = transformer(nb, resources)
         return nb, resources
 
 
     def _get_default_options(self, export_format):
         """ Load the default options for built in formats.
 
         export_format: Format being exported to.
         """
 
         c = get_config()
         
         #Set default data extraction priorities.
         c.GlobalConfigurable.display_data_priority =['svg', 'png', 'latex', 'jpg', 'jpeg','text']
         c.ExtractFigureTransformer.display_data_priority=['svg', 'png', 'latex', 'jpg', 'jpeg','text']
         c.ConverterTemplate.display_data_priority= ['svg', 'png', 'latex', 'jpg', 'jpeg','text']
 
         #For most (or all cases), the template file name matches the format name.
         c.ConverterTemplate.template_file = export_format
 
         if export_format == "basichtml" or "fullhtml" or "reveal":
             c.CSSHtmlHeaderTransformer.enabled=True
             if export_format == 'reveal'
                 c.NbconvertApp.fileext='reveal.html'
             else:
                 c.NbconvertApp.fileext='html'
 
         elif export_format == "latex_sphinx_howto" or export_format == "latex_sphinx_manual":
 
             #Turn on latex environment 
             c.ConverterTemplate.tex_environement=True
 
             #Standard latex extension
             c.NbconvertApp.fileext='tex'
 
             #Prioritize latex extraction for latex exports.
             c.GlobalConfigurable.display_data_priority =['latex', 'svg', 'png', 'jpg', 'jpeg' , 'text']
             c.ExtractFigureTransformer.display_data_priority=['latex', 'svg', 'png', 'jpg', 'jpeg']
             c.ExtractFigureTransformer.extra_ext_map={'svg':'pdf'}
             c.ExtractFigureTransformer.enabled=True
             
             # Enable latex transformers (make markdown2latex work with math $.)
             c.LatexTransformer.enabled=True
             c.SphinxTransformer.enabled = True
 
         elif export_format == 'markdown':
             c.NbconvertApp.fileext='md'
             c.ExtractFigureTransformer.enabled=True
             
         elif export_format == 'python':
             c.NbconvertApp.fileext='py'
 
 
         elif export_format == 'rst':
             c.NbconvertApp.fileext='rst'
             c.ExtractFigureTransformer.enabled=True
         return c
 
 
     #TODO: Comment me.
     def _rm_fake(strng):
         return strng.replace('/files/', '')
 
 
     #TODO: Comment me.
     def _python_comment(string):
         return '# '+'\n# '.join(string.split('\n'))
 
 
     #TODO: Comment me.
     def _escape_tex(value):
         newval = value
         for pattern, replacement in LATEX_SUBS:
             newval = pattern.sub(replacement, newval)
         return newval
  No newline at end of file

transformers/latex.py

@@ -1,75 +1,92 b''
-"""
+"""Latex transformer.
+
 Module that allows latex output notebooks to be conditioned before
 they are converted.
 """
-from __future__ import absolute_import
+#-----------------------------------------------------------------------------
+# 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.
+#-----------------------------------------------------------------------------
 
-# Configurable traitlets
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+from __future__ import print_function, absolute_import
 
+# Our own imports
 # Needed to override transformer
-from .transformers import (ActivatableTransformer)
+from .transformers import (ActivatableTransformer) #TODO
 
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
 class LatexTransformer(ActivatableTransformer):
     """
     Converter for latex destined documents.
     """
 
     def cell_transform(self, cell, other, index):
         """
         Apply a transformation on each cell,
 
         receive the current cell, the resource dict and the index of current cell as parameter.
 
         Returns modified cell and resource dict.
         """
         if hasattr(cell, "source") and cell.cell_type == "markdown":
             cell.source = rm_math_space(cell.source)
         return cell, other
 
+#-----------------------------------------------------------------------------
+# Functions
+#-----------------------------------------------------------------------------
 def rm_math_space(text):
     """
     Remove the space between latex math commands and enclosing $ symbols.
     """
 
     # First, scan through the markdown looking for $.  If
     # a $ symbol is found, without a preceding \, assume
     # it is the start of a math block.  UNLESS that $ is
     # not followed by another within two math_lines.
     math_regions = []
     math_lines = 0
     within_math = False
     math_start_index = 0
     ptext = ''
     last_character = ""
     skip = False
     for index, char in enumerate(text):
         #Make sure the character isn't preceeded by a backslash
         if (char == "$" and last_character != "\\"):
             # Close the math region if this is an ending $
             if within_math:
                 within_math = False
                 skip = True
                 ptext = ptext+'$'+text[math_start_index+1:index].strip()+'$'
                 math_regions.append([math_start_index, index+1])
             else:
                 # Start a new math region
                 within_math = True
                 math_start_index = index
                 math_lines = 0
         # If we are in a math region, count the number of lines parsed.
         # Cancel the math region if we find two line breaks!
         elif char == "\n":
             if within_math:
                 math_lines += 1
                 if math_lines > 1:
                     within_math = False
                     ptext = ptext+text[math_start_index:index]
 
         # Remember the last character so we can easily watch
         # for backslashes
         last_character = char
         if not within_math and not skip:
             ptext = ptext+char
         if skip:
             skip = False
     return ptext

transformers/sphinx.py

@@ -1,271 +1,287 b''
-"""
-Module that allows custom Sphinx parameters to be set on the notebook and
+"""Module that allows custom Sphinx parameters to be set on the notebook and
 on the 'other' object passed into Jinja.
 """
-from __future__ import absolute_import
+#-----------------------------------------------------------------------------
+# 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 determine python version
 import sys
 
 # Used to set the default date to today's date 
 from datetime import date 
 
-# Configurable traitlets
-from IPython.utils.traitlets import Unicode, Bool
-
+# 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 .transformers import (ActivatableTransformer)
+from .transformers import (ActivatableTransformer) #TODO
 
+#-----------------------------------------------------------------------------
+# 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(True, 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.
     """)
     
     overridetitle = Unicode("", config=True, help="")
     
     def __call__(self, nb, other):
         """
         Entry
         Since we are not interested in any additional manipulation on a cell
         by cell basis, we do not  call the base implementation.
         """ 
         if self.enabled:
             return self.transform(nb, other)
         else:
             return nb,other
 
     def transform(self, nb, other):
         """
         Sphinx transformation to apply on each notebook.
         """
          
         # TODO: Add versatile method of additional notebook metadata.  Include
         #       handling of multiple files.  For now use a temporay namespace,
         #       '_draft' to signify that this needs to change.
         if not "_draft" in nb.metadata:
             nb.metadata._draft = {}
             
         if not "sphinx" in other:
             other["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.
             other["sphinx"]["chapterstyle"] = self._prompt_chapter_title_style()
             other["sphinx"]["outputstyle"] = self._prompt_output_style()
             
             # Small options
             other["sphinx"]["centeroutput"] = self._prompt_boolean("Do you want to center the output? (false)", False)
             other["sphinx"]["header"] = self._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.
             other["sphinx"]["chapterstyle"] = self.chapter_style
             other["sphinx"]["outputstyle"] = self.output_style
             other["sphinx"]["centeroutput"] = self.center_output
             other["sphinx"]["header"] = self.use_headers
             
         # Find and pass in the path to the Sphinx dependencies.
         other["sphinx"]["texinputs"] = os.path.abspath(sphinx.__file__ + "/../texinputs")
         
         # Generate Pygments definitions for Latex 
         other["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, other 
     
     def _generate_pygments_latex_def(self):
         return LatexFormatter().get_style_defs()       
     
     def _prompt_author(self):
         return  self._input("Author name: ")
     
     def _prompt_version(self):
         return  self._input("Version (ie ""1.0.0""): ")
     
     def _prompt_release(self):
         return  self._input("Release Name (ie ""Rough draft""): ")
     
     def _prompt_date(self):
         default_date = date.today().strftime("%B %-d, %Y")
         user_date = self._input("Date (deafults to \"" + default_date + "\"): ")
         if len(user_date.strip()) == 0:
             user_date = default_date
         return user_date
     
     def _prompt_boolean(self, prompt, default=False):
         response = self._input(prompt)
         response = response.strip().lower()
         
         #Catch 1, true, yes as True
         if len(response) > 0 and (response == "1" or response[0] == "t" or response[0] == "y"):
             return True
         
         #Catch 0, false, no as False
         elif len(response) > 0 and (response == "0" or response[0] == "f" or response[0] == "n"):
             return False
             
         else:
             return default
         
     def _prompt_output_style(self):
         
         # 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 self._prompt_dictionary(styles, default_style=2, menu_comments=comments)
     
     def _prompt_chapter_title_style(self):
         
         # 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 self._prompt_dictionary(styles, menu_comments=comments)
     
     def _prompt_dictionary(self, choices, default_style=1, menu_comments={}):
                 
         # Build the menu that will be displayed to the user with
         # all of the options available. 
         prompt = ""
         for key, value in choices.iteritems():
             prompt += "%d %s " % (key, value)
             if key in menu_comments:
                 prompt += menu_comments[key]
             prompt += "\n"
         
         # Continue to ask the user for a style until an appropriate
         # one is specified.
         response = -1
         while (not response in choices):
             try:
                 text_response = self._input(prompt)
                 
                 # Use default option if no input.
                 if len(text_response.strip()) == 0:
                     response = default_style
                 else:
                     response = int(text_response)
             except:
                 print("Error: Value is not an available option.  0 selects the default.\n")
         return choices[response]
           
     def _input(self, prompt_text):
         """
         Prompt the user for input.
         
         The input command will change depending on the version of python
         installed.  To maintain support for 2 and earlier, we must use
         raw_input in that case.  Else use input.
         """
         
         # Try to get the python version.  This command is only available in
         # python 2 and later, so it's important that we catch the exception
         # if the command isn't found.
         try:
             majorversion = sys.version_info[0]
         except:
             majorversion = 1
             
         # Use the correct function to prompt the user for input depending on 
         # what python version the code is running in.
         if majorversion >= 3:
             return input(prompt_text) 
         else:
             return raw_input(prompt_text)