Fixed errors after testing...

IPython/nbconvert/writers/pdf.py

@@ -0,0 +1,42 b''
+#!/usr/bin/env python
+"""
+Contains writer for writing nbconvert output to PDF.
+"""
+#-----------------------------------------------------------------------------
+#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 subprocess
+import os
+
+from IPython.utils.traitlets import Integer
+
+from .files import FilesWriter
+
+#-----------------------------------------------------------------------------
+# Classes
+#-----------------------------------------------------------------------------
+class PDFWriter(FilesWriter):
+    """Writer designed to write to PDF files"""
+
+    iteration_count = Integer(3, config=True, help="""
+        How many times pdflatex will be called.
+        """)
+
+    def write(self, output, resources, notebook_name=None, **kw):
+            """
+            Consume and write Jinja output a PDF.  
+            See files.py for more...
+            """        
+            dest = super(PDFWriter, self).write(output, resources, notebook_name=notebook_name, **kw)
+            command = 'pdflatex ' + dest
+            for index in range(self.iteration_count):
+                subprocess.Popen(command, shell=True, stdout=open(os.devnull, 'wb'))

IPython/nbconvert/nbconvertapp.py

@@ -1,249 +1,259 b''
 #!/usr/bin/env python
 """NBConvert is a utility for conversion of .ipynb files.
 
 Command-line interface for the NbConvert conversion utility.
 """
 #-----------------------------------------------------------------------------
 #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, base_aliases, base_flags
 from IPython.config import catch_config_error, Configurable
 from IPython.utils.traitlets import (
     Unicode, List, Instance, DottedObjectName, Type, CaselessStrEnum,
 )
 from IPython.utils.importstring import import_item
 
 from .exporters.export import export_by_name, get_export_names, ExporterNameError
 from IPython.nbconvert import exporters, transformers, writers
 from .utils.base import NbConvertBase
 from .utils.exceptions import ConversionException
 
 #-----------------------------------------------------------------------------
 #Classes and functions
 #-----------------------------------------------------------------------------
 
 nbconvert_aliases = {}
 nbconvert_aliases.update(base_aliases)
 nbconvert_aliases.update({
     'to' : 'NbConvertApp.export_format',
     'flavor' : 'Exporter.flavor',
     'template' : 'Exporter.template_file',
     'notebooks' : 'NbConvertApp.notebooks',
     'writer' : 'NbConvertApp.writer_class',
 })
 
 nbconvert_flags = {}
 nbconvert_flags.update(base_flags)
 nbconvert_flags.update({
     'stdout' : (
         {'NbConvertApp' : {'writer_class' : "StdoutWriter"}},
         "Write notebook output to stdout instead of files."
+        ),
+
+    'pdf' : (
+        {'NbConvertApp' : {'writer_class' : "PDFWriter"}},
+        "Compile notebook output to a PDF."
         )
 })
 
 
 class NbConvertApp(BaseIPythonApplication):
     """Application used to convert to and from notebook file type (*.ipynb)"""
 
     name = 'ipython-nbconvert'
     aliases = nbconvert_aliases
     flags = nbconvert_flags
     
     def _classes_default(self):
         classes = [NbConvertBase]
         for pkg in (exporters, transformers, writers):
             for name in dir(pkg):
                 cls = getattr(pkg, name)
                 if isinstance(cls, type) and issubclass(cls, Configurable):
                     classes.append(cls)
         return classes
 
     description = Unicode(
         u"""This application is used to convert notebook files (*.ipynb)
         to various other formats.""")
 
     examples = Unicode(u"""
         The simplest way to use nbconvert is
         
         > ipython nbconvert mynotebook.ipynb
         
         which will convert mynotebook.ipynb to the default format (probably HTML).
         
         You can specify the export format with `--to`.
         Options include {0}
         
         > ipython nbconvert --to latex mynotebook.ipnynb
 
         Both HTML and LaTeX support multiple flavors of output. LaTeX includes
         'basic', 'book', and 'article'.  HTML includes 'basic', 'full', and 
         'reveal'.  You can specify the flavor of the format used.
 
         > ipython nbconvert --to html --flavor reveal mynotebook.ipnynb
         
         You can also pipe the output to stdout, rather than a file
         
         > ipython nbconvert mynotebook.ipynb --stdout
+
+        or to a PDF
+
+        > ipython nbconvert mynotebook.ipynb --pdf
         
         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
         
         or you can specify the notebooks list in a config file, containing::
         
             c.NbConvertApp.notebooks = ["my_notebook.ipynb"]
         
         > ipython nbconvert --config mycfg.py
         """.format(get_export_names()))
     # 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',
+                      'PDFWriter': 'IPython.nbconvert.writers.pdf.PDFWriter',
                       '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 = CaselessStrEnum(get_export_names(),
         default_value="html",
         config=True,
         help="""The export format to be used."""
     )
 
     notebooks = List([], config=True, help="""List of notebooks to convert.
                      Wildcards are supported.
                      Filenames passed positionally will be added to the list.
                      """)
 
     @catch_config_error
     def initialize(self, argv=None):
         super(NbConvertApp, self).initialize(argv)
         self.init_syspath()
         self.init_notebooks()
         self.init_writer()
 
 
     def init_syspath(self):
         """
         Add the cwd to the sys.path ($PYTHONPATH)
         """
         sys.path.insert(0, os.getcwd())
         
 
     def init_notebooks(self):
         """Construct the list of notebooks.
         If notebooks are passed on the command-line,
         they override notebooks specified in config files.
         Glob each notebook to replace notebook patterns with filenames.
         """
 
         # Specifying notebooks on the command-line overrides (rather than adds)
         # the notebook list
         if self.extra_args:
             patterns = self.extra_args
         else:
             patterns = self.notebooks
 
         # Use glob to replace all the notebook patterns with filenames.
         filenames = []
         for pattern in patterns:
             
             # Use glob to find matching filenames.  Allow the user to convert 
             # notebooks without having to type the extension.
             globbed_files = glob.glob(pattern)
             globbed_files.extend(glob.glob(pattern + '.ipynb'))
 
             for filename in globbed_files:
                 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):
         """
         Ran after initialization 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
             resources['output_files_dir'] = '%s_files' % 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 while converting '%s': '%s' exporter not found."
                       %(notebook_filename, self.export_format),
                       file=sys.stderr)
                 print("Known exporters are:",
                       "\n\t" + "\n\t".join(get_export_names()),
                       file=sys.stderr)
                 self.exit(1)
             except ConversionException as e:
                 print("Error while converting '%s': %s" %(notebook_filename, e),
                       file=sys.stderr)
                 self.exit(1)
             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:
             self.print_help()
             sys.exit(-1)
 
 
 #-----------------------------------------------------------------------------
 # Main entry point
 #-----------------------------------------------------------------------------
 
 launch_new_instance = NbConvertApp.launch_instance

IPython/nbconvert/templates/latex/latex_basic.tplx

@@ -1,258 +1,260 b''
 ((*- extends 'display_priority.tplx' -*))
 
+\nonstopmode
+
 ((* block in_prompt *))((* endblock in_prompt *))
 
 ((* block output_prompt *))((* endblock output_prompt *))
 
 ((* block codecell *))\begin{codecell}((( super() )))
 \end{codecell}
 ((* endblock *))
 
 ((* block input *))
 \begin{codeinput}
 \begin{lstlisting}
 ((( cell.input )))
 \end{lstlisting}
 \end{codeinput}
 ((* endblock input *))
 
 
 ((= Those Two are for error displaying
 even if the first one seem to do nothing, 
 it introduces a new line
 
 =))
 ((* block pyerr *))
 \begin{traceback}
 \begin{verbatim}((( super() )))
 \end{verbatim}
 \end{traceback}
 ((* endblock pyerr *))
 
 ((* block traceback_line *))
 ((( line |indent| strip_ansi )))((* endblock traceback_line *))
 ((= .... =))
 
 
 ((*- block output_group -*))
 \begin{codeoutput}
 ((( super() )))
 \end{codeoutput}((* endblock *))
 
 ((*- block data_png -*))
 \begin{center}
 \includegraphics[max size={0.7\textwidth}{0.9\textheight}]{(((output.png_filename)))}
 \par
 \end{center}
 ((*- endblock -*))
 
 ((*- block data_jpg -*))
 \begin{center}
 \includegraphics[max size={0.7\textwidth}{0.9\textheight}]{(((output.jpeg_filename)))}
 \par
 \end{center}
 ((*- endblock -*))
 
 ((*- block data_svg -*))
 \begin{center}
 \includegraphics[width=0.7\textwidth]{(((output.svg_filename)))}
 \par
 \end{center}
 ((*- endblock -*))
 
 ((*- block data_pdf -*))
 \begin{center}
 \includegraphics[width=0.7\textwidth]{(((output.pdf_filename)))}
 \par
 \end{center}
 ((*- endblock -*))
 
 ((* block pyout *))
 ((* block data_priority scoped *))((( super() )))((* endblock *))
 ((* endblock pyout *))
 
 ((* block data_text *))
 \begin{verbatim}
 ((( output.text )))
 \end{verbatim}
 ((* endblock *))
 
 ((* block data_latex -*))
 ((*- if output.latex.startswith('$'): -*)) \begin{equation*}
     ((( output.latex | strip_dollars)))
     \end{equation*}
 ((*- else -*)) ((( output.latex ))) ((*- endif *))
 ((* endblock *))
 
 ((* block stream *))
 \begin{Verbatim}[commandchars=\\\{\}]
 ((( output.text | ansi2latex)))
 \end{Verbatim}
 ((* endblock stream *))
 
 ((* block markdowncell scoped *))((( cell.source | markdown2latex )))
 ((* endblock markdowncell *))
 
 ((* block headingcell scoped -*))
     ((( ('#' * cell.level + cell.source) | replace('\n', ' ') | markdown2latex )))
 ((* endblock headingcell *))
 
 ((* block rawcell scoped *))
 ((( cell.source | comment_lines )))
 ((* endblock rawcell *))
 
 ((* block unknowncell scoped *))
 unknown type  (((cell.type)))
 ((* endblock unknowncell *))
 
 
 
 ((* block body *))
 
 ((* block bodyBegin *))
 \begin{document}
 ((* endblock bodyBegin *))
 
 ((( super() )))
 
 ((* block bodyEnd *))
 \end{document}
 ((* endblock bodyEnd *))
 ((* endblock body *))
 
 ((* block header *))
 %% This file was auto-generated by IPython.
 %% Conversion from the original notebook file:
 %%
 \documentclass[11pt,english]{article}
 
 %% This is the automatic preamble used by IPython.  Note that it does *not*
 %% include a documentclass declaration, that is added at runtime to the overall
 %% document.
 
 \usepackage{amsmath}
 \usepackage{amssymb}
 \usepackage{graphicx}
 \usepackage{ucs}
 \usepackage[utf8x]{inputenc}
 
 % Scale down larger images
 \usepackage[export]{adjustbox}
 
 %fancy verbatim
 \usepackage{fancyvrb}
 % needed for markdown enumerations to work
 \usepackage{enumerate}
 
 % Slightly bigger margins than the latex defaults
 \usepackage{geometry}
 \geometry{verbose,tmargin=3cm,bmargin=3cm,lmargin=2.5cm,rmargin=2.5cm}
 
 % Define a few colors for use in code, links and cell shading
 \usepackage{color}
 \definecolor{orange}{cmyk}{0,0.4,0.8,0.2}
 \definecolor{darkorange}{rgb}{.71,0.21,0.01}
 \definecolor{darkgreen}{rgb}{.12,.54,.11}
 \definecolor{myteal}{rgb}{.26, .44, .56}
 \definecolor{gray}{gray}{0.45}
 \definecolor{lightgray}{gray}{.95}
 \definecolor{mediumgray}{gray}{.8}
 \definecolor{inputbackground}{rgb}{.95, .95, .85}
 \definecolor{outputbackground}{rgb}{.95, .95, .95}
 \definecolor{traceback}{rgb}{1, .95, .95}
 
 % new ansi colors
 \definecolor{brown}{rgb}{0.54,0.27,0.07}
 \definecolor{purple}{rgb}{0.5,0.0,0.5}
 \definecolor{darkgray}{gray}{0.25}
 \definecolor{lightred}{rgb}{1.0,0.39,0.28}
 \definecolor{lightgreen}{rgb}{0.48,0.99,0.0}
 \definecolor{lightblue}{rgb}{0.53,0.81,0.92}
 \definecolor{lightpurple}{rgb}{0.87,0.63,0.87}
 \definecolor{lightcyan}{rgb}{0.5,1.0,0.83}
 
 % Framed environments for code cells (inputs, outputs, errors, ...).  The
 % various uses of \unskip (or not) at the end were fine-tuned by hand, so don't
 % randomly change them unless you're sure of the effect it will have.
 \usepackage{framed}
 
 % remove extraneous vertical space in boxes
 \setlength\fboxsep{0pt}
 
 % codecell is the whole input+output set of blocks that a Code cell can
 % generate.
 
 % TODO: unfortunately, it seems that using a framed codecell environment breaks
 % the ability of the frames inside of it to be broken across pages.  This
 % causes at least the problem of having lots of empty space at the bottom of
 % pages as new frames are moved to the next page, and if a single frame is too
 % long to fit on a page, will completely stop latex from compiling the
 % document.  So unless we figure out a solution to this, we'll have to instead
 % leave the codecell env. as empty.  I'm keeping the original codecell
 % definition here (a thin vertical bar) for reference, in case we find a
 % solution to the page break issue.
 
 %% \newenvironment{codecell}{%
 %%     \def\FrameCommand{\color{mediumgray} \vrule width 1pt \hspace{5pt}}%
 %%    \MakeFramed{\vspace{-0.5em}}}
 %%  {\unskip\endMakeFramed}
 
 % For now, make this a no-op...
 \newenvironment{codecell}{}
 
  \newenvironment{codeinput}{%
    \def\FrameCommand{\colorbox{inputbackground}}%
    \MakeFramed{\advance\hsize-\width \FrameRestore}}
  {\unskip\endMakeFramed}
 
 \newenvironment{codeoutput}{%
    \def\FrameCommand{\colorbox{outputbackground}}%
    \vspace{-1.4em}
    \MakeFramed{\advance\hsize-\width \FrameRestore}}
  {\unskip\medskip\endMakeFramed}
 
 \newenvironment{traceback}{%
    \def\FrameCommand{\colorbox{traceback}}%
    \MakeFramed{\advance\hsize-\width \FrameRestore}}
  {\endMakeFramed}
 
 % Use and configure listings package for nicely formatted code
 \usepackage{listingsutf8}
 \lstset{
   language=python,
   inputencoding=utf8x,
   extendedchars=\true,
   aboveskip=\smallskipamount,
   belowskip=\smallskipamount,
   xleftmargin=2mm,
   breaklines=true,
   basicstyle=\small \ttfamily,
   showstringspaces=false,
   keywordstyle=\color{blue}\bfseries,
   commentstyle=\color{myteal},
   stringstyle=\color{darkgreen},
   identifierstyle=\color{darkorange},
   columns=fullflexible,  % tighter character kerning, like verb
 }
 
 % The hyperref package gives us a pdf with properly built
 % internal navigation ('pdf bookmarks' for the table of contents,
 % internal cross-reference links, web links for URLs, etc.)
 \usepackage{hyperref}
 \hypersetup{
   breaklinks=true,  % so long urls are correctly broken across lines
   colorlinks=true,
   urlcolor=blue,
   linkcolor=darkorange,
   citecolor=darkgreen,
   }
 
 % hardcode size of all verbatim environments to be a bit smaller
 \makeatletter 
 \g@addto@macro\@verbatim\small\topsep=0.5em\partopsep=0pt
 \makeatother 
 
 % Prevent overflowing lines due to urls and other hard-to-break entities.
 \sloppy
 
 ((* endblock *))

IPython/nbconvert/templates/latex/sphinx.tplx

@@ -1,450 +1,452 b''
 ((= NBConvert Sphinx-Latex Template
 
 Purpose: Allow export of PDF friendly Latex inspired by Sphinx.  Most of the
        template is derived directly from Sphinx source.
 
 Inheritance: null>display_priority 
 
 Note: For best display, use latex syntax highlighting. =))
 
 ((*- extends 'display_priority.tplx' -*))
 
+\nonstopmode
+
 %==============================================================================
 % Declarations
 %==============================================================================
 
 % In order to make sure that the input/output header follows the code it 
 % preceeds, the needspace package is used to request that a certain
 % amount of lines (specified by this variable) are reserved.  If those
 % lines aren't available on the current page, the documenter will break
 % to the next page and the header along with accomanying lines will be
 % rendered together.  This value specifies the number of lines that
 % the header will be forced to group with without a page break.
 ((*- set min_header_lines = 4 -*))
 
 % This is the number of characters that are permitted per line.  It's
 % important that this limit is set so characters do not run off the
 % edges of latex pages (since latex does not always seem smart enough
 % to prevent this in some cases.)  This is only applied to textual output
 ((* if resources.sphinx.outputstyle == 'simple' *))
     ((*- set wrap_size = 85 -*))
 ((* elif resources.sphinx.outputstyle == 'notebook' *))
     ((*- set wrap_size = 70 -*))
 ((* endif *))
 
 %==============================================================================
 % Header
 %==============================================================================
 ((* block header *))
 
 % Header, overrides base
 
     % Make sure that the sphinx doc style knows who it inherits from.
     \def\sphinxdocclass{(((parentdocumentclass)))}
 
     % Declare the document class
     \documentclass[letterpaper,10pt,english]{((( resources.sphinx.texinputs )))/sphinx(((documentclass)))}
 
     % Imports
     \usepackage[utf8]{inputenc}
     \DeclareUnicodeCharacter{00A0}{\\nobreakspace}
     \usepackage[T1]{fontenc}
     \usepackage{babel}
     \usepackage{times}
     \usepackage{import}
     \usepackage[((( resources.sphinx.chapterstyle )))]{((( resources.sphinx.texinputs )))/fncychap}
     \usepackage{longtable}
     \usepackage{((( resources.sphinx.texinputs )))/sphinx}
     \usepackage{multirow}
 
     \usepackage{amsmath}
     \usepackage{amssymb}
     \usepackage{ucs}
     \usepackage{enumerate}
 
     % Used to make the Input/Output rules follow around the contents.
     \usepackage{needspace}
 
     % Pygments requirements
     \usepackage{fancyvrb}
     \usepackage{color}
     % ansi colors additions
     \definecolor{darkgreen}{rgb}{.12,.54,.11}
     \definecolor{lightgray}{gray}{.95}
     \definecolor{brown}{rgb}{0.54,0.27,0.07}
     \definecolor{purple}{rgb}{0.5,0.0,0.5}
     \definecolor{darkgray}{gray}{0.25}
     \definecolor{lightred}{rgb}{1.0,0.39,0.28}
     \definecolor{lightgreen}{rgb}{0.48,0.99,0.0}
     \definecolor{lightblue}{rgb}{0.53,0.81,0.92}
     \definecolor{lightpurple}{rgb}{0.87,0.63,0.87}
     \definecolor{lightcyan}{rgb}{0.5,1.0,0.83}
 
     % Needed to box output/input
     \usepackage{tikz}
         \usetikzlibrary{calc,arrows,shadows}
     \usepackage[framemethod=tikz]{mdframed}
 
     \usepackage{alltt}
 
     % Used to load and display graphics
     \usepackage{graphicx}
     \graphicspath{ {figs/} }
     \usepackage[Export]{adjustbox} % To resize
 
 
     % For formatting output while also word wrapping.
     \usepackage{listings}
     \lstset{breaklines=true}
     \lstset{basicstyle=\small\ttfamily}
     \def\smaller{\fontsize{9.5pt}{9.5pt}\selectfont}
 
     %Pygments definitions
     ((( resources.sphinx.pygment_definitions )))
 
     %Set pygments styles if needed...
     ((* if resources.sphinx.outputstyle == 'notebook' *))
         \definecolor{nbframe-border}{rgb}{0.867,0.867,0.867}
         \definecolor{nbframe-bg}{rgb}{0.969,0.969,0.969}
         \definecolor{nbframe-in-prompt}{rgb}{0.0,0.0,0.502}
         \definecolor{nbframe-out-prompt}{rgb}{0.545,0.0,0.0}
 
         \newenvironment{ColorVerbatim}
         {\begin{mdframed}[%
             roundcorner=1.0pt, %
             backgroundcolor=nbframe-bg, %
             userdefinedwidth=1\linewidth, %
             leftmargin=0.1\linewidth, %
             innerleftmargin=0pt, %
             innerrightmargin=0pt, %
             linecolor=nbframe-border, %
             linewidth=1pt, %
             usetwoside=false, %
             everyline=true, %
             innerlinewidth=3pt, %
             innerlinecolor=nbframe-bg, %
             middlelinewidth=1pt, %
             middlelinecolor=nbframe-bg, %
             outerlinewidth=0.5pt, %
             outerlinecolor=nbframe-border, %
             needspace=0pt
         ]}
         {\end{mdframed}}
         
         \newenvironment{InvisibleVerbatim}
         {\begin{mdframed}[leftmargin=0.1\linewidth,innerleftmargin=3pt,innerrightmargin=3pt, userdefinedwidth=1\linewidth, linewidth=0pt, linecolor=white, usetwoside=false]}
         {\end{mdframed}}
 
         \renewenvironment{Verbatim}[1][\unskip]
         {\begin{alltt}\smaller}
         {\end{alltt}}
     ((* endif *))
 
     % Help prevent overflowing lines due to urls and other hard-to-break 
     % entities.  This doesn't catch everything...
     \sloppy
 
     % Document level variables
     \title{((( resources.metadata.name | escape_latex )))}
     \date{((( resources.sphinx.date | escape_latex )))}
     \release{((( resources.sphinx.version | escape_latex )))}
     \author{((( resources.sphinx.author | escape_latex )))}
     \renewcommand{\releasename}{((( resources.sphinx.release | escape_latex )))}
 
     % TODO: Add option for the user to specify a logo for his/her export.
     \newcommand{\sphinxlogo}{}
 
     % Make the index page of the document.
     \makeindex
 
     % Import sphinx document type specifics.
     ((* block sphinxheader *))((* endblock sphinxheader *)) 
 ((* endblock header *))
 
 %==============================================================================
 % Body
 %==============================================================================
 ((* block body *))
 ((* block bodyBegin *))
 % Body
 
     % Start of the document
     \begin{document}
 
         ((* if resources.sphinx.header *))
             \maketitle
         ((* endif *))
 
         ((* block toc *))
             \tableofcontents 
         ((* endblock toc *))
 
         ((* endblock bodyBegin *))((( super() )))((* block bodyEnd *))
 
         \renewcommand{\indexname}{Index}
         \printindex
 
     % End of document
     \end{document}
 ((* endblock bodyEnd *))
 ((* endblock body *))
 
 %==============================================================================
 % Footer
 %==============================================================================
 ((* block footer *))
 ((* endblock footer *))
 
 %==============================================================================
 % Headings
 %
 % Purpose: Format pynb headers as sphinx headers.  Depending on the Sphinx
 %          style that is active, this will change.  Thus sphinx styles will
 %          override the values here.
 %==============================================================================
 ((* block headingcell -*))
     \
     ((*- if cell.level == 1 -*))
         ((* block h1 -*))part((* endblock h1 -*))
     ((*- elif cell.level == 2 -*))
         ((* block h2 -*))chapter((* endblock h2 -*))
     ((*- elif cell.level == 3 -*))
         ((* block h3 -*))section((* endblock h3 -*))
     ((*- elif cell.level == 4 -*))
         ((* block h4 -*))subsection((* endblock h4 -*))
     ((*- elif cell.level == 5 -*))
         ((* block h5 -*))subsubsection((* endblock h5 -*))
     ((*- elif cell.level == 6 -*))
         ((* block h6 -*))paragraph((* endblock h6 -*))
 
     ((= It's important to make sure that underscores (which tend to be common
     in IPYNB file titles) do not make their way into latex.  Sometimes this
     causes latex to barf. =))
     ((*- endif -*)){((( cell.source | markdown2latex )))}
 ((*- endblock headingcell *))
 
 %==============================================================================
 % Markdown
 %
 % Purpose: Convert markdown to latex.  Here markdown2latex is explicitly
 %          called since we know we want latex output.
 %==============================================================================
 ((*- block markdowncell scoped-*))
     ((( cell.source | markdown2latex )))
 ((*- endblock markdowncell -*))
 
 %==============================================================================
 % Rawcell
 %
 % Purpose: Raw text cells allow the user to manually inject document code that 
 %          will not get touched by the templating system.
 %==============================================================================
 ((*- block rawcell *))
     ((( cell.source | wrap_text(wrap_size) )))
 ((* endblock rawcell -*))
 
 %==============================================================================
 % Unknowncell
 %
 % Purpose: This is the catch anything unhandled.  To display this data, we
 %          remove all possible latex conflicts and wrap the characters so they
 %          can't flow off of the page.
 %==============================================================================
 ((* block unknowncell scoped*))
 
     % Unsupported cell type, no formatting
     ((( cell.source | wrap_text | escape_latex )))
 ((* endblock unknowncell *))
 
 %==============================================================================
 % Input
 %==============================================================================
 ((* block input *))
 
     % Make sure that atleast 4 lines are below the HR
     \needspace{((( min_header_lines )))\baselineskip}
 
     ((* if resources.sphinx.outputstyle == 'simple' *))
 
         % Add a horizantal break, along with break title.
         \vspace{10pt}
         {\scriptsize Input}\\*
         \rule[10pt]{\linewidth}{0.5pt}
         \vspace{-25pt}
 
         % Add contents below.
         ((( cell.input | highlight2latex )))
 
     ((* elif resources.sphinx.outputstyle == 'notebook' *))
         \vspace{6pt}
         ((( write_prompt("In", cell.prompt_number, "nbframe-in-prompt") )))
         \vspace{-2.65\baselineskip}
         \begin{ColorVerbatim}
             \vspace{-0.7\baselineskip}
             ((( cell.input | highlight2latex )))
             ((* if cell.input == None or cell.input == '' *))
                 \vspace{0.3\baselineskip}
             ((* else *))
                 \vspace{-0.2\baselineskip}
             ((* endif *))
         \end{ColorVerbatim}
     ((* endif *))
 ((* endblock input *))
 
 %==============================================================================
 % Output_Group
 %
 % Purpose: Make sure that only one header bar only attaches to the output 
 %          once.  By keeping track of when an input group is started
 %==============================================================================
 ((* block output_group *))
     ((* if cell.outputs.__len__() > 0 *))
 
         % If the first block is an image, minipage the image.  Else
         % request a certain amount of space for the input text.
         ((( iff_figure(cell.outputs[0], "\\begin{minipage}{1.0\\textwidth}", "\\needspace{"  ~ min_header_lines ~ "\\baselineskip}") )))
         
         ((* if resources.sphinx.outputstyle == 'simple' *))
 
             % Add a horizantal break, along with break title.
             \vspace{10pt}
             {\scriptsize Output}\\*
             \rule[10pt]{\linewidth}{0.5pt}
             \vspace{-20pt}
 
             % Add the contents of the first block.
             ((( render_output(cell.outputs[0]) )))
 
             % Close the minipage.
             ((( iff_figure(cell.outputs[0], "\\end{minipage}", "") )))
 
             % Add remainer of the document contents below.
             ((* for output in cell.outputs[1:] *))
                 ((( render_output(output, cell.prompt_number) )))
             ((* endfor *))
         ((* elif resources.sphinx.outputstyle == 'notebook' *))
 
             % Add document contents.
             ((* for output in cell.outputs *))
                 ((( render_output(output, cell.prompt_number) )))
             ((* endfor *))
         ((* endif *))
     ((* endif *))
 ((* endblock *))
 
 %==============================================================================
 % Additional formating
 %==============================================================================
 ((* block data_text *))
     ((( custom_verbatim(output.text) | ansi2latex)))
 ((* endblock *))
 
 ((* block traceback_line *))
     ((( conditionally_center_output(line | indent| strip_ansi) )))
 ((* endblock traceback_line *))
 
 %==============================================================================
 % Supported image formats
 %==============================================================================
 ((*- block data_png -*))
     ((( conditionally_center_output(insert_graphics(output.png_filename)) )))
 ((*- endblock -*))
 
 ((*- block data_jpg -*))
     ((( conditionally_center_output(insert_graphics(output.jpg_filename)) )))
 ((*- endblock -*))
 
 ((*- block data_svg -*))
     ((( conditionally_center_output(insert_graphics(output.svg_filename)) )))
 ((*- endblock -*))
 
 ((*- block data_pdf -*))
     ((( conditionally_center_output(insert_graphics(output.pdf_filename)) )))
 ((*- endblock -*))
 
 ((*- block data_latex *))
     ((* if resources.sphinx.centeroutput *))\begin{center}((* endif -*))((( output.latex | strip_math_space )))((*- if resources.sphinx.centeroutput *))\end{center} ((* endif -*))
 ((*- endblock -*))
 
 %==============================================================================
 % Support Macros
 %==============================================================================
 
 % Name: write_prompt
 % Purpose: Renders an output/input prompt for notebook style pdfs
 ((* macro write_prompt(prompt, number, color) -*))
     \makebox[0.1\linewidth]{\smaller\hfill\tt\color{((( color )))}((( prompt )))\hspace{4pt}{[}((( number ))){]}:\hspace{4pt}}\\*
 ((*- endmacro *))
 
 % Name: render_output
 % Purpose: Renders an output block appropriately.
 ((* macro render_output(output, prompt_number) -*))
     ((*- if output.output_type == 'pyerr' -*))
         ((*- block pyerr scoped *))
             ((( custom_verbatim(super()) )))
         ((* endblock pyerr -*))
     ((*- else -*))
 
         ((* if resources.sphinx.outputstyle == 'notebook' *))
             ((*- if output.output_type == 'pyout' -*))
                 ((( write_prompt("Out", prompt_number, "nbframe-out-prompt") )))
                 \vspace{-2.55\baselineskip}
             ((*- endif -*))
 
             \begin{InvisibleVerbatim}
                 \vspace{-0.5\baselineskip}
         ((*- endif -*))
 
         ((*- block display_data scoped -*))
             ((( super() )))
         ((*- endblock display_data -*))
 
         ((* if resources.sphinx.outputstyle == 'notebook' *))
             \end{InvisibleVerbatim}
         ((*- endif -*))
     ((*- endif -*))
 ((*- endmacro *))
 
 % Name: iff_figure
 % Purpose: If the output block provided is a figure type, the 'true_content'
 %          parameter will be returned.  Else, the 'false_content'. 
 ((* macro iff_figure(output, true_content, false_content) -*))
     ((*- set is_figure = false -*))
     ((*- for type in output | filter_data_type -*))
         ((*- if type in ['pdf', 'svg', 'png', 'jpeg','html']*))
             ((*- set is_figure = true -*))
         ((*- endif -*))
     ((*- endfor -*))
     
     ((* if is_figure -*))
         ((( true_content )))
     ((*- else -*))
         ((( false_content )))
     ((*- endif *))
 ((*- endmacro *))
 
 % Name: custom_verbatim
 % Purpose: This macro creates a verbatim style block that fits the existing
 %          sphinx style more readily than standard verbatim blocks.
 ((* macro custom_verbatim(text) -*))
     \begin{alltt}
     ((*- if resources.sphinx.centeroutput *))\begin{center} ((* endif -*))
 ((( text | wrap_text(wrap_size) )))
     ((*- if resources.sphinx.centeroutput *))\end{center}((* endif -*))
     \end{alltt}
 ((*- endmacro *))
 
 % Name: conditionally_center_output
 % Purpose: This macro centers the output if the output centering is enabled.
 ((* macro conditionally_center_output(text) -*))
     ((* if resources.sphinx.centeroutput *)){\centering ((* endif *))((( text )))((* if resources.sphinx.centeroutput *))}((* endif *))
 ((*- endmacro *))
 
 % Name: insert_graphics
 % Purpose: This macro will insert an image in the latex document given a path.
 ((* macro insert_graphics(path) -*))
     \begin{center}
     \includegraphics[max size={\textwidth}{\textheight}]{(((path)))}
     \par
     \end{center}
 ((*- endmacro *))

IPython/nbconvert/writers/__init__.py

@@ -1,2 +1,3 b''
 from .files import FilesWriter
 from .stdout import StdoutWriter
+from .pdf import PDFWriter

IPython/nbconvert/writers/files.py

@@ -1,102 +1,103 b''
 #!/usr/bin/env python
 """
 Contains writer for writing nbconvert output to filesystem.
 """
 #-----------------------------------------------------------------------------
 #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 io
 import os
 import glob
 
 from IPython.utils.traitlets import Unicode
 from IPython.utils.path import link_or_copy
 
 from .base import WriterBase
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class FilesWriter(WriterBase):
     """Consumes nbconvert output and produces files."""
 
 
     build_directory = Unicode(".", config=True, 
                               help="""Directory to write output to.  Leave blank
                               to output to the current directory""")
 
 
     # Make sure that the output directory exists.
     def _build_directory_changed(self, name, old, new):
         if new and not os.path.isdir(new):
             os.makedirs(new)
 
 
     def __init__(self, **kw):
         super(FilesWriter, self).__init__(**kw)
         self._build_directory_changed('build_directory', self.build_directory, 
                                       self.build_directory)
 
 
     def write(self, output, resources, notebook_name=None, **kw):
             """
             Consume and write Jinja output to the file system.  Output directory
             is set via the 'build_directory' variable of this instance (a 
             configurable).
 
             See base for more...
             """
 
             # Pull the extension and subdir from the resources dict.
             output_extension = resources['output_extension']
 
             # Write all of the extracted resources to the destination directory.
             # NOTE: WE WRITE EVERYTHING AS-IF IT'S BINARY.  THE EXTRACT FIG
             # TRANSFORMER SHOULD HANDLE UNIX/WINDOWS LINE ENDINGS...
             for filename, data in resources.get('outputs', {}).items():
 
                 # Determine where to write the file to
                 dest = os.path.join(self.build_directory, filename)
                 path = os.path.dirname(dest)
                 if not os.path.isdir(path):
                     os.makedirs(path)
 
                 # Write file
                 with io.open(dest, 'wb') as f:
                     f.write(data)
 
             # Copy referenced files to output directory
             if self.build_directory:
                 for filename in self.files:
 
                     # Copy files that match search pattern
                     for matching_filename in glob.glob(filename):
 
                         # Make sure folder exists.
                         dest = os.path.join(self.build_directory, filename)
                         path = os.path.dirname(dest)
                         if not os.path.isdir(path):
                             os.makedirs(path)
 
                         # Copy if destination is different.
                         if not os.path.normpath(dest) == os.path.normpath(matching_filename):
                             link_or_copy(matching_filename, dest)
 
             # Determine where to write conversion results.
             dest = notebook_name + '.' + output_extension
             if self.build_directory:
                 dest = os.path.join(self.build_directory, dest)
 
             # Write conversion results.
             with io.open(dest, 'w') as f:
                 f.write(output)
+            return dest 
  No newline at end of file