Merge pull request #5586 from minrk/pdf-exporter

add PDFExporter

IPython/nbconvert/exporters/tests/test_pdf.py

@@ -0,0 +1,36 b''
+"""Tests for PDF export"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import logging
+import os
+
+from IPython.testing import decorators as dec
+
+from .base import ExportersTestsBase
+from ..pdf import PDFExporter
+
+
+#-----------------------------------------------------------------------------
+# Class
+#-----------------------------------------------------------------------------
+
+class TestPDF(ExportersTestsBase):
+    """Test PDF export"""
+
+    exporter_class = PDFExporter
+
+    def test_constructor(self):
+        """Can a PDFExporter be constructed?"""
+        self.exporter_class()
+
+
+    @dec.onlyif_cmds_exist('pdflatex')
+    @dec.onlyif_cmds_exist('pandoc')
+    def test_export(self):
+        """Smoke test PDFExporter"""
+        (output, resources) = self.exporter_class(latex_count=1).from_filename(self._get_notebook())
+        self.assertIsInstance(output, bytes)
+        assert len(output) > 0
+

docs/source/whatsnew/pr/incompat-rm-pdf-post.rst

@@ -0,0 +1,2 b''
+Creating PDFs with LaTeX no longer uses a post processor.
+Use `nbconvert --to pdf` instead of `nbconvert --to latex --post pdf`.

IPython/html/nbconvert/handlers.py

@@ -1,140 +1,140 b''
 import io
 import os
 import zipfile
 
 from tornado import web
 
 from ..base.handlers import IPythonHandler, notebook_path_regex
 from IPython.nbformat.current import to_notebook_json
 
 from IPython.utils import tz
 from IPython.utils.py3compat import cast_bytes
 
 import sys
 
 def find_resource_files(output_files_dir):
     files = []
     for dirpath, dirnames, filenames in os.walk(output_files_dir):
         files.extend([os.path.join(dirpath, f) for f in filenames])
     return files
 
 def respond_zip(handler, name, output, resources):
     """Zip up the output and resource files and respond with the zip file.
 
     Returns True if it has served a zip file, False if there are no resource
     files, in which case we serve the plain output file.
     """
     # Check if we have resource files we need to zip
     output_files = resources.get('outputs', None)
     if not output_files:
         return False
 
     # Headers
     zip_filename = os.path.splitext(name)[0] + '.zip'
     handler.set_header('Content-Disposition',
                        'attachment; filename="%s"' % zip_filename)
     handler.set_header('Content-Type', 'application/zip')
 
     # Prepare the zip file
     buffer = io.BytesIO()
     zipf = zipfile.ZipFile(buffer, mode='w', compression=zipfile.ZIP_DEFLATED)
     output_filename = os.path.splitext(name)[0] + '.' + resources['output_extension']
     zipf.writestr(output_filename, cast_bytes(output, 'utf-8'))
     for filename, data in output_files.items():
         zipf.writestr(os.path.basename(filename), data)
     zipf.close()
 
     handler.finish(buffer.getvalue())
     return True
 
 def get_exporter(format, **kwargs):
     """get an exporter, raising appropriate errors"""
     # if this fails, will raise 500
     try:
         from IPython.nbconvert.exporters.export import exporter_map
     except ImportError as e:
         raise web.HTTPError(500, "Could not import nbconvert: %s" % e)
     
     try:
         Exporter = exporter_map[format]
     except KeyError:
         # should this be 400?
         raise web.HTTPError(404, u"No exporter for format: %s" % format)
     
     try:
         return Exporter(**kwargs)
     except Exception as e:
         raise web.HTTPError(500, "Could not construct Exporter: %s" % e)
 
 class NbconvertFileHandler(IPythonHandler):
 
     SUPPORTED_METHODS = ('GET',)
     
     @web.authenticated
     def get(self, format, path='', name=None):
         
-        exporter = get_exporter(format, config=self.config)
+        exporter = get_exporter(format, config=self.config, log=self.log)
         
         path = path.strip('/')
         model = self.notebook_manager.get_notebook(name=name, path=path)
 
         self.set_header('Last-Modified', model['last_modified'])
         
         try:
             output, resources = exporter.from_notebook_node(model['content'])
         except Exception as e:
             raise web.HTTPError(500, "nbconvert failed: %s" % e)
 
         if respond_zip(self, name, output, resources):
             return
 
         # Force download if requested
         if self.get_argument('download', 'false').lower() == 'true':
             filename = os.path.splitext(name)[0] + '.' + resources['output_extension']
             self.set_header('Content-Disposition',
                                'attachment; filename="%s"' % filename)
 
         # MIME type
         if exporter.output_mimetype:
             self.set_header('Content-Type',
                             '%s; charset=utf-8' % exporter.output_mimetype)
 
         self.finish(output)
 
 class NbconvertPostHandler(IPythonHandler):
     SUPPORTED_METHODS = ('POST',)
 
     @web.authenticated 
     def post(self, format):
         exporter = get_exporter(format, config=self.config)
         
         model = self.get_json_body()
         nbnode = to_notebook_json(model['content'])
         
         try:
             output, resources = exporter.from_notebook_node(nbnode)
         except Exception as e:
             raise web.HTTPError(500, "nbconvert failed: %s" % e)
 
         if respond_zip(self, nbnode.metadata.name, output, resources):
             return
 
         # MIME type
         if exporter.output_mimetype:
             self.set_header('Content-Type',
                             '%s; charset=utf-8' % exporter.output_mimetype)
 
         self.finish(output)
 
 #-----------------------------------------------------------------------------
 # URL to handler mappings
 #-----------------------------------------------------------------------------
 
 _format_regex = r"(?P<format>\w+)"
 
 
 default_handlers = [
     (r"/nbconvert/%s%s" % (_format_regex, notebook_path_regex),
          NbconvertFileHandler),
     (r"/nbconvert/%s" % _format_regex, NbconvertPostHandler),
 ]
  No newline at end of file

IPython/html/static/notebook/js/menubar.js

@@ -1,335 +1,335 b''
-//----------------------------------------------------------------------------
-//  Copyright (C) 2008-2011  The IPython Development Team
-//
-//  Distributed under the terms of the BSD License.  The full license is in
-//  the file COPYING, distributed as part of this software.
-//----------------------------------------------------------------------------
+// Copyright (c) IPython Development Team.
+// Distributed under the terms of the Modified BSD License.
 
 //============================================================================
 // MenuBar
 //============================================================================
 
 /**
  * @module IPython
  * @namespace IPython
  * @submodule MenuBar
  */
 
 
 var IPython = (function (IPython) {
     "use strict";
     
     var utils = IPython.utils;
 
     /**
      * A MenuBar Class to generate the menubar of IPython notebook
      * @Class MenuBar
      *
      * @constructor
      *
      *
      * @param selector {string} selector for the menubar element in DOM
      * @param {object} [options]
      *      @param [options.base_url] {String} String to use for the
      *      base project url. Default is to inspect
      *      $('body').data('baseUrl');
      *      does not support change for now is set through this option
      */
     var MenuBar = function (selector, options) {
         options = options || {};
         this.base_url = options.base_url || IPython.utils.get_body_data("baseUrl");
         this.selector = selector;
         if (this.selector !== undefined) {
             this.element = $(selector);
             this.style();
             this.bind_events();
         }
     };
 
     MenuBar.prototype.style = function () {
         this.element.addClass('border-box-sizing');
         this.element.find("li").click(function (event, ui) {
                 // The selected cell loses focus when the menu is entered, so we
                 // re-select it upon selection.
                 var i = IPython.notebook.get_selected_index();
                 IPython.notebook.select(i);
             }
         );
     };
 
     MenuBar.prototype._nbconvert = function (format, download) {
         download = download || false;
         var notebook_path = IPython.notebook.notebook_path;
         var notebook_name = IPython.notebook.notebook_name;
         if (IPython.notebook.dirty) {
             IPython.notebook.save_notebook({async : false});
         }
         var url = utils.url_join_encode(
             this.base_url,
             'nbconvert',
             format,
             notebook_path,
             notebook_name
         ) + "?download=" + download.toString();
 
         window.open(url);
     };
 
     MenuBar.prototype.bind_events = function () {
         //  File
         var that = this;
         this.element.find('#new_notebook').click(function () {
             IPython.notebook.new_notebook();
         });
         this.element.find('#open_notebook').click(function () {
             window.open(utils.url_join_encode(
                 IPython.notebook.base_url,
                 'tree',
                 IPython.notebook.notebook_path
             ));
         });
         this.element.find('#copy_notebook').click(function () {
             IPython.notebook.copy_notebook();
             return false;
         });
         this.element.find('#download_ipynb').click(function () {
             var base_url = IPython.notebook.base_url;
             var notebook_path = IPython.notebook.notebook_path;
             var notebook_name = IPython.notebook.notebook_name;
             if (IPython.notebook.dirty) {
                 IPython.notebook.save_notebook({async : false});
             }
             
             var url = utils.url_join_encode(
                 base_url,
                 'files',
                 notebook_path,
                 notebook_name
             );
             window.location.assign(url);
         });
         
         this.element.find('#print_preview').click(function () {
             that._nbconvert('html', false);
         });
 
         this.element.find('#download_py').click(function () {
             that._nbconvert('python', true);
         });
 
         this.element.find('#download_html').click(function () {
             that._nbconvert('html', true);
         });
 
         this.element.find('#download_rst').click(function () {
             that._nbconvert('rst', true);
         });
 
+        this.element.find('#download_pdf').click(function () {
+            that._nbconvert('pdf', true);
+        });
+
         this.element.find('#rename_notebook').click(function () {
             IPython.save_widget.rename_notebook();
         });
         this.element.find('#save_checkpoint').click(function () {
             IPython.notebook.save_checkpoint();
         });
         this.element.find('#restore_checkpoint').click(function () {
         });
         this.element.find('#trust_notebook').click(function () {
             IPython.notebook.trust_notebook();
         });
         $([IPython.events]).on('trust_changed.Notebook', function (event, trusted) {
             if (trusted) {
                 that.element.find('#trust_notebook')
                     .addClass("disabled")
                     .find("a").text("Trusted Notebook");
             } else {
                 that.element.find('#trust_notebook')
                     .removeClass("disabled")
                     .find("a").text("Trust Notebook");
             }
         });
         this.element.find('#kill_and_exit').click(function () {
             IPython.notebook.session.delete();
             setTimeout(function(){
                 // allow closing of new tabs in Chromium, impossible in FF
                 window.open('', '_self', '');
                 window.close();
             }, 500);
         });
         // Edit
         this.element.find('#cut_cell').click(function () {
             IPython.notebook.cut_cell();
         });
         this.element.find('#copy_cell').click(function () {
             IPython.notebook.copy_cell();
         });
         this.element.find('#delete_cell').click(function () {
             IPython.notebook.delete_cell();
         });
         this.element.find('#undelete_cell').click(function () {
             IPython.notebook.undelete_cell();
         });
         this.element.find('#split_cell').click(function () {
             IPython.notebook.split_cell();
         });
         this.element.find('#merge_cell_above').click(function () {
             IPython.notebook.merge_cell_above();
         });
         this.element.find('#merge_cell_below').click(function () {
             IPython.notebook.merge_cell_below();
         });
         this.element.find('#move_cell_up').click(function () {
             IPython.notebook.move_cell_up();
         });
         this.element.find('#move_cell_down').click(function () {
             IPython.notebook.move_cell_down();
         });
         this.element.find('#edit_nb_metadata').click(function () {
             IPython.notebook.edit_metadata();
         });
         
         // View
         this.element.find('#toggle_header').click(function () {
             $('div#header').toggle();
             IPython.layout_manager.do_resize();
         });
         this.element.find('#toggle_toolbar').click(function () {
             $('div#maintoolbar').toggle();
             IPython.layout_manager.do_resize();
         });
         // Insert
         this.element.find('#insert_cell_above').click(function () {
             IPython.notebook.insert_cell_above('code');
             IPython.notebook.select_prev();
         });
         this.element.find('#insert_cell_below').click(function () {
             IPython.notebook.insert_cell_below('code');
             IPython.notebook.select_next();
         });
         // Cell
         this.element.find('#run_cell').click(function () {
             IPython.notebook.execute_cell();
         });
         this.element.find('#run_cell_select_below').click(function () {
             IPython.notebook.execute_cell_and_select_below();
         });
         this.element.find('#run_cell_insert_below').click(function () {
             IPython.notebook.execute_cell_and_insert_below();
         });
         this.element.find('#run_all_cells').click(function () {
             IPython.notebook.execute_all_cells();
         });
         this.element.find('#run_all_cells_above').click(function () {
             IPython.notebook.execute_cells_above();
         });
         this.element.find('#run_all_cells_below').click(function () {
             IPython.notebook.execute_cells_below();
         });
         this.element.find('#to_code').click(function () {
             IPython.notebook.to_code();
         });
         this.element.find('#to_markdown').click(function () {
             IPython.notebook.to_markdown();
         });
         this.element.find('#to_raw').click(function () {
             IPython.notebook.to_raw();
         });
         this.element.find('#to_heading1').click(function () {
             IPython.notebook.to_heading(undefined, 1);
         });
         this.element.find('#to_heading2').click(function () {
             IPython.notebook.to_heading(undefined, 2);
         });
         this.element.find('#to_heading3').click(function () {
             IPython.notebook.to_heading(undefined, 3);
         });
         this.element.find('#to_heading4').click(function () {
             IPython.notebook.to_heading(undefined, 4);
         });
         this.element.find('#to_heading5').click(function () {
             IPython.notebook.to_heading(undefined, 5);
         });
         this.element.find('#to_heading6').click(function () {
             IPython.notebook.to_heading(undefined, 6);
         });
         
         this.element.find('#toggle_current_output').click(function () {
             IPython.notebook.toggle_output();
         });
         this.element.find('#toggle_current_output_scroll').click(function () {
             IPython.notebook.toggle_output_scroll();
         });
         this.element.find('#clear_current_output').click(function () {
             IPython.notebook.clear_output();
         });
         
         this.element.find('#toggle_all_output').click(function () {
             IPython.notebook.toggle_all_output();
         });
         this.element.find('#toggle_all_output_scroll').click(function () {
             IPython.notebook.toggle_all_output_scroll();
         });
         this.element.find('#clear_all_output').click(function () {
             IPython.notebook.clear_all_output();
         });
         
         // Kernel
         this.element.find('#int_kernel').click(function () {
             IPython.notebook.session.interrupt_kernel();
         });
         this.element.find('#restart_kernel').click(function () {
             IPython.notebook.restart_kernel();
         });
         // Help
         this.element.find('#notebook_tour').click(function () {
             IPython.tour.start();
         });
         this.element.find('#keyboard_shortcuts').click(function () {
             IPython.quick_help.show_keyboard_shortcuts();
         });
         
         this.update_restore_checkpoint(null);
         
         $([IPython.events]).on('checkpoints_listed.Notebook', function (event, data) {
             that.update_restore_checkpoint(IPython.notebook.checkpoints);
         });
         
         $([IPython.events]).on('checkpoint_created.Notebook', function (event, data) {
             that.update_restore_checkpoint(IPython.notebook.checkpoints);
         });
     };
 
     MenuBar.prototype.update_restore_checkpoint = function(checkpoints) {
         var ul = this.element.find("#restore_checkpoint").find("ul");
         ul.empty();
         if (!checkpoints || checkpoints.length === 0) {
             ul.append(
                 $("<li/>")
                 .addClass("disabled")
                 .append(
                     $("<a/>")
                     .text("No checkpoints")
                 )
             );
             return;
         }
         
         checkpoints.map(function (checkpoint) {
             var d = new Date(checkpoint.last_modified);
             ul.append(
                 $("<li/>").append(
                     $("<a/>")
                     .attr("href", "#")
                     .text(d.format("mmm dd HH:MM:ss"))
                     .click(function () {
                         IPython.notebook.restore_checkpoint_dialog(checkpoint);
                     })
                 )
             );
         });
     };
 
     IPython.MenuBar = MenuBar;
 
     return IPython;
 
 }(IPython));

IPython/html/templates/notebook.html

@@ -1,361 +1,362 b''
 {% extends "page.html" %}
 
 {% block stylesheet %}
 
 {% if mathjax_url %}
 <script type="text/javascript" src="{{mathjax_url}}?config=TeX-AMS_HTML-full&delayStartupUntil=configured" charset="utf-8"></script>
 {% endif %}
 <script type="text/javascript">
 // MathJax disabled, set as null to distingish from *missing* MathJax,
 // where it will be undefined, and should prompt a dialog later.
 window.mathjax_url = "{{mathjax_url}}";
 </script>
 
 <link rel="stylesheet" href="{{ static_url("components/bootstrap-tour/build/css/bootstrap-tour.min.css") }}" type="text/css" />
 <link rel="stylesheet" href="{{ static_url("components/codemirror/lib/codemirror.css") }}">
 
 {{super()}}
 
 <link rel="stylesheet" href="{{ static_url("notebook/css/override.css") }}" type="text/css" />
 
 {% endblock %}
 
 {% block params %}
 
 data-project="{{project}}"
 data-base-url="{{base_url}}"
 data-notebook-name="{{notebook_name}}"
 data-notebook-path="{{notebook_path}}"
 class="notebook_app"
 
 {% endblock %}
 
 
 {% block header %}
 
 <span id="save_widget" class="nav pull-left">
     <span id="notebook_name"></span>
     <span id="checkpoint_status"></span>
     <span id="autosave_status"></span>
 </span>
 
 {% endblock %}
 
 
 {% block site %}
 
 <div id="menubar-container" class="container">
 <div id="menubar">
 <div class="navbar">
   <div class="navbar-inner">
     <div class="container">
     <ul id="menus" class="nav">
         <li class="dropdown"><a href="#" class="dropdown-toggle" data-toggle="dropdown">File</a>
             <ul id="file_menu" class="dropdown-menu">
                 <li id="new_notebook"
                     title="Make a new notebook (Opens a new window)">
                     <a href="#">New</a></li>
                 <li id="open_notebook"
                     title="Opens a new window with the Dashboard view">
                     <a href="#">Open...</a></li>
                 <!-- <hr/> -->
                 <li class="divider"></li>
                 <li id="copy_notebook"
                     title="Open a copy of this notebook's contents and start a new kernel">
                     <a href="#">Make a Copy...</a></li>
                 <li id="rename_notebook"><a href="#">Rename...</a></li>
                 <li id="save_checkpoint"><a href="#">Save and Checkpoint</a></li>
                 <!-- <hr/> -->
                 <li class="divider"></li>
                 <li id="restore_checkpoint" class="dropdown-submenu"><a href="#">Revert to Checkpoint</a>
                   <ul class="dropdown-menu">
                     <li><a href="#"></a></li>
                     <li><a href="#"></a></li>
                     <li><a href="#"></a></li>
                     <li><a href="#"></a></li>
                     <li><a href="#"></a></li>
                   </ul>
                 </li>
                 <li class="divider"></li>
                 <li id="print_preview"><a href="#">Print Preview</a></li>
                 <li class="dropdown-submenu"><a href="#">Download as</a>
                     <ul class="dropdown-menu">
                         <li id="download_ipynb"><a href="#">IPython Notebook (.ipynb)</a></li>
                         <li id="download_py"><a href="#">Python (.py)</a></li>
                         <li id="download_html"><a href="#">HTML (.html)</a></li>
                         <li id="download_rst"><a href="#">reST (.rst)</a></li>
+                        <li id="download_pdf"><a href="#">PDF (.pdf)</a></li>
                     </ul>
                 </li>
                 <li class="divider"></li>
                 <li id="trust_notebook"
                     title="Trust the output of this notebook">
                     <a href="#" >Trust Notebook</a></li>
                 <li class="divider"></li>
                 <li id="kill_and_exit"
                     title="Shutdown this notebook's kernel, and close this window">
                     <a href="#" >Close and halt</a></li>
             </ul>
         </li>
         <li class="dropdown"><a href="#" class="dropdown-toggle" data-toggle="dropdown">Edit</a>
             <ul id="edit_menu" class="dropdown-menu">
                 <li id="cut_cell"><a href="#">Cut Cell</a></li>
                 <li id="copy_cell"><a href="#">Copy Cell</a></li>
                 <li id="paste_cell_above" class="disabled"><a href="#">Paste Cell Above</a></li>
                 <li id="paste_cell_below" class="disabled"><a href="#">Paste Cell Below</a></li>
                 <li id="paste_cell_replace" class="disabled"><a href="#">Paste Cell &amp; Replace</a></li>
                 <li id="delete_cell"><a href="#">Delete Cell</a></li>
                 <li id="undelete_cell" class="disabled"><a href="#">Undo Delete Cell</a></li>
                 <li class="divider"></li>
                 <li id="split_cell"><a href="#">Split Cell</a></li>
                 <li id="merge_cell_above"><a href="#">Merge Cell Above</a></li>
                 <li id="merge_cell_below"><a href="#">Merge Cell Below</a></li>
                 <li class="divider"></li>
                 <li id="move_cell_up"><a href="#">Move Cell Up</a></li>
                 <li id="move_cell_down"><a href="#">Move Cell Down</a></li>
                 <li class="divider"></li>
                 <li id="edit_nb_metadata"><a href="#">Edit Notebook Metadata</a></li>
             </ul>
         </li>
         <li class="dropdown"><a href="#" class="dropdown-toggle" data-toggle="dropdown">View</a>
             <ul id="view_menu" class="dropdown-menu">
                 <li id="toggle_header"
                     title="Show/Hide the IPython Notebook logo and notebook title (above menu bar)">
                     <a href="#">Toggle Header</a></li>
                 <li id="toggle_toolbar"
                     title="Show/Hide the action icons (below menu bar)">
                     <a href="#">Toggle Toolbar</a></li>
             </ul>
         </li>
         <li class="dropdown"><a href="#" class="dropdown-toggle" data-toggle="dropdown">Insert</a>
             <ul id="insert_menu" class="dropdown-menu">
                 <li id="insert_cell_above"
                     title="Insert an empty Code cell above the currently active cell">
                     <a href="#">Insert Cell Above</a></li>
                 <li id="insert_cell_below"
                     title="Insert an empty Code cell below the currently active cell">
                     <a href="#">Insert Cell Below</a></li>
             </ul>
         </li>
         <li class="dropdown"><a href="#" class="dropdown-toggle" data-toggle="dropdown">Cell</a>
             <ul id="cell_menu" class="dropdown-menu">
                 <li id="run_cell" title="Run this cell, and move cursor to the next one">
                     <a href="#">Run</a></li>
                 <li id="run_cell_select_below" title="Run this cell, select below">
                     <a href="#">Run and Select Below</a></li>
                 <li id="run_cell_insert_below" title="Run this cell, insert below">
                     <a href="#">Run and Insert Below</a></li>
                 <li id="run_all_cells" title="Run all cells in the notebook">
                     <a href="#">Run All</a></li>
                 <li id="run_all_cells_above" title="Run all cells above (but not including) this cell">
                     <a href="#">Run All Above</a></li>
                 <li id="run_all_cells_below" title="Run this cell and all cells below it">
                     <a href="#">Run All Below</a></li>
                 <li class="divider"></li>
                 <li id="change_cell_type" class="dropdown-submenu"
                     title="All cells in the notebook have a cell type. By default, new cells are created as 'Code' cells">
                     <a href="#">Cell Type</a>
                     <ul class="dropdown-menu">
                       <li id="to_code"
                           title="Contents will be sent to the kernel for execution, and output will display in the footer of cell">
                           <a href="#">Code</a></li>
                       <li id="to_markdown"
                           title="Contents will be rendered as HTML and serve as explanatory text">
                           <a href="#">Markdown</a></li>
                       <li id="to_raw"
                           title="Contents will pass through nbconvert unmodified">
                           <a href="#">Raw NBConvert</a></li>
                       <li id="to_heading1"><a href="#">Heading 1</a></li>
                       <li id="to_heading2"><a href="#">Heading 2</a></li>
                       <li id="to_heading3"><a href="#">Heading 3</a></li>
                       <li id="to_heading4"><a href="#">Heading 4</a></li>
                       <li id="to_heading5"><a href="#">Heading 5</a></li>
                       <li id="to_heading6"><a href="#">Heading 6</a></li>
                     </ul>
                 </li>
                 <li class="divider"></li>
                 <li id="current_outputs" class="dropdown-submenu"><a href="#">Current Output</a>
                     <ul class="dropdown-menu">
                         <li id="toggle_current_output"
                             title="Hide/Show the output of the current cell">
                             <a href="#">Toggle</a>
                         </li>
                         <li id="toggle_current_output_scroll"
                             title="Scroll the output of the current cell">
                             <a href="#">Toggle Scrolling</a>
                         </li>
                         <li id="clear_current_output"
                             title="Clear the output of the current cell">
                             <a href="#">Clear</a>
                         </li>
                     </ul>
                 </li>
                 <li id="all_outputs" class="dropdown-submenu"><a href="#">All Output</a>
                     <ul class="dropdown-menu">
                         <li id="toggle_all_output"
                             title="Hide/Show the output of all cells">
                             <a href="#">Toggle</a>
                         </li>
                         <li id="toggle_all_output_scroll"
                             title="Scroll the output of all cells">
                             <a href="#">Toggle Scrolling</a>
                         </li>
                         <li id="clear_all_output"
                             title="Clear the output of all cells">
                             <a href="#">Clear</a>
                         </li>
                     </ul>
                 </li>
             </ul>
         </li>
         <li class="dropdown"><a href="#" class="dropdown-toggle" data-toggle="dropdown">Kernel</a>
             <ul id="kernel_menu" class="dropdown-menu">
                 <li id="int_kernel"
                     title="Send KeyboardInterrupt (CTRL-C) to the Kernel">
                     <a href="#">Interrupt</a></li>
                 <li id="restart_kernel"
                     title="Restart the Kernel">
                     <a href="#">Restart</a></li>
             </ul>
         </li>
         <li class="dropdown"><a href="#" class="dropdown-toggle" data-toggle="dropdown">Help</a>
             <ul  id="help_menu" class="dropdown-menu">
                 <li id="notebook_tour" title="A quick tour of the notebook user interface"><a href="#">User Interface Tour</a></li>
                 <li id="keyboard_shortcuts" title="Opens a tooltip with all keyboard shortcuts"><a href="#">Keyboard Shortcuts</a></li>
                 <li class="divider"></li>
                 {% set
                     sections = (
                         (
                             ("http://ipython.org/documentation.html","IPython Help",True),
                             ("http://nbviewer.ipython.org/github/ipython/ipython/tree/2.x/examples/Index.ipynb", "Notebook Help", True),
                         ),(
                             ("http://docs.python.org","Python",True),
                             ("http://help.github.com/articles/github-flavored-markdown","Markdown",True),
                             ("http://docs.scipy.org/doc/numpy/reference/","NumPy",True),
                             ("http://docs.scipy.org/doc/scipy/reference/","SciPy",True),
                             ("http://matplotlib.org/contents.html","Matplotlib",True),
                             ("http://docs.sympy.org/latest/index.html","SymPy",True),
                             ("http://pandas.pydata.org/pandas-docs/stable/","pandas", True)
                         )
                     )
                 %}
 
                 {% for helplinks in sections %}
                     {% for link in helplinks %}
                         <li><a href="{{link[0]}}" {{'target="_blank" title="Opens in a new window"' if link[2]}}>
                         {{'<i class="icon-external-link menu-icon pull-right"></i>' if link[2]}}
                         {{link[1]}}
                         </a></li>
                     {% endfor %}
                     {% if not loop.last %}
                         <li class="divider"></li>
                     {% endif %}
                 {% endfor %}
                 </li>
             </ul>
         </li>
     </ul>
     <div id="kernel_indicator" class="indicator_area pull-right">
        <i id="kernel_indicator_icon"></i>
     </div>
     <div id="modal_indicator" class="indicator_area pull-right">
        <i id="modal_indicator_icon"></i>
     </div>
     <div id="notification_area"></div>
     </div>
   </div>
 </div>
 </div>
 <div id="maintoolbar" class="navbar">
   <div class="toolbar-inner navbar-inner navbar-nobg">
     <div id="maintoolbar-container" class="container"></div>
   </div>
 </div>
 </div>
 
 <div id="ipython-main-app">
 
     <div id="notebook_panel">
         <div id="notebook"></div>
         <div id="pager_splitter"></div>
         <div id="pager">
             <div id='pager_button_area'>
             </div>
             <div id="pager-container" class="container"></div>
         </div>
     </div>
 
 </div>
 <div id='tooltip' class='ipython_tooltip' style='display:none'></div>
 
 
 {% endblock %}
 
 
 {% block script %}
 
 {{super()}}
 
 <script src="{{ static_url("components/google-caja/html-css-sanitizer-minified.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/lib/codemirror.js") }}" charset="utf-8"></script>
 <script type="text/javascript">
     CodeMirror.modeURL = "{{ static_url("components/codemirror/mode/%N/%N.js", include_version=False) }}";
 </script>
 <script src="{{ static_url("components/codemirror/addon/mode/loadmode.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/addon/mode/multiplex.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/addon/mode/overlay.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/addon/edit/matchbrackets.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/addon/edit/closebrackets.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/addon/comment/comment.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/mode/htmlmixed/htmlmixed.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/mode/xml/xml.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/mode/javascript/javascript.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/mode/css/css.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/mode/rst/rst.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/mode/markdown/markdown.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/mode/gfm/gfm.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/mode/python/python.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/codemirror-ipython.js") }}" charset="utf-8"></script>
 
 <script src="{{ static_url("components/highlight.js/build/highlight.pack.js") }}" charset="utf-8"></script>
 
 <script src="{{ static_url("dateformat/date.format.js") }}" charset="utf-8"></script>
 
 <script src="{{ static_url("base/js/events.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("base/js/utils.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("base/js/keyboard.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("base/js/security.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("base/js/dialog.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("services/kernels/js/kernel.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("services/kernels/js/comm.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("services/sessions/js/session.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/layoutmanager.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/mathjaxutils.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/outputarea.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/cell.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/celltoolbar.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/codecell.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/completer.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/textcell.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/savewidget.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/quickhelp.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/pager.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/menubar.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/toolbar.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/maintoolbar.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/notebook.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/keyboardmanager.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/notificationwidget.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/notificationarea.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/tooltip.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/tour.js") }}" type="text/javascript" charset="utf-8"></script>
 
 <script src="{{ static_url("notebook/js/config.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/main.js") }}" type="text/javascript" charset="utf-8"></script>
 
 <script src="{{ static_url("notebook/js/contexthint.js") }}" charset="utf-8"></script>
 
 <script src="{{ static_url("notebook/js/celltoolbarpresets/default.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/celltoolbarpresets/rawcell.js") }}" type="text/javascript" charset="utf-8"></script>
 <script src="{{ static_url("notebook/js/celltoolbarpresets/slideshow.js") }}" type="text/javascript" charset="utf-8"></script>
 
 {% endblock %}

IPython/nbconvert/exporters/__init__.py

@@ -1,9 +1,10 b''
 from .export import *
 from .html import HTMLExporter
 from .slides import SlidesExporter
 from .templateexporter import TemplateExporter
 from .latex import LatexExporter
 from .markdown import MarkdownExporter
+from .pdf import PDFExporter
 from .python import PythonExporter
 from .rst import RSTExporter
 from .exporter import Exporter

IPython/nbconvert/exporters/export.py

@@ -1,179 +1,172 b''
-"""
-Module containing single call export functions.
-"""
-#-----------------------------------------------------------------------------
-# 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.
-#-----------------------------------------------------------------------------
+"""Module containing single call export functions."""
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 from functools import wraps
 
 from IPython.nbformat.v3.nbbase import NotebookNode
 from IPython.utils.decorators import undoc
 from IPython.utils.py3compat import string_types
 
 from .exporter import Exporter
 from .templateexporter import TemplateExporter
 from .html import HTMLExporter
 from .slides import SlidesExporter
 from .latex import LatexExporter
+from .pdf import PDFExporter
 from .markdown import MarkdownExporter
 from .python import PythonExporter
 from .rst import RSTExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 @undoc
 def DocDecorator(f):
     
     #Set docstring of function
     f.__doc__ = f.__doc__ + """
     nb : :class:`~{nbnode_mod}.NotebookNode`
       The notebook to export.
     config : config (optional, keyword arg)
         User configuration instance.
     resources : dict (optional, keyword arg)
         Resources used in the conversion process.
         
     Returns
     -------
     tuple- output, resources, exporter_instance
     output : str
         Jinja 2 output.  This is the resulting converted notebook.
     resources : dictionary
         Dictionary of resources used prior to and during the conversion 
         process.
     exporter_instance : Exporter
         Instance of the Exporter class used to export the document.  Useful
         to caller because it provides a 'file_extension' property which
         specifies what extension the output should be saved as.
 
     Notes
     -----
     WARNING: API WILL CHANGE IN FUTURE RELEASES OF NBCONVERT
     """.format(nbnode_mod=NotebookNode.__module__)
             
     @wraps(f)
     def decorator(*args, **kwargs):
         return f(*args, **kwargs)
     
     return decorator
 
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 __all__ = [
     'export',
     'export_html',
     'export_custom',
     'export_slides',
     'export_latex',
+    'export_pdf',
     'export_markdown',
     'export_python',
     'export_rst',
     'export_by_name',
     'get_export_names',
     'ExporterNameError'
 ]
 
 
 class ExporterNameError(NameError):
     pass
 
 @DocDecorator
 def export(exporter, nb, **kw):
     """
     Export a notebook object using specific exporter class.
     
     Parameters
     ----------
     exporter : class:`~IPython.nbconvert.exporters.exporter.Exporter` class or instance
       Class type or instance of the exporter that should be used.  If the
       method initializes it's own instance of the class, it is ASSUMED that
       the class type provided exposes a constructor (``__init__``) with the same
       signature as the base Exporter class.
     """
     
     #Check arguments
     if exporter is None:
         raise TypeError("Exporter is None")
     elif not isinstance(exporter, Exporter) and not issubclass(exporter, Exporter):
         raise TypeError("exporter does not inherit from Exporter (base)")
     if nb is None:
         raise TypeError("nb is None")
     
     #Create the exporter
     resources = kw.pop('resources', None)
     if isinstance(exporter, Exporter):
         exporter_instance = exporter
     else:
         exporter_instance = exporter(**kw)
     
     #Try to convert the notebook using the appropriate conversion function.
     if isinstance(nb, NotebookNode):
         output, resources = exporter_instance.from_notebook_node(nb, resources)
     elif isinstance(nb, string_types):
         output, resources = exporter_instance.from_filename(nb, resources)
     else:
         output, resources = exporter_instance.from_file(nb, resources)
     return output, resources
 
 exporter_map = dict(
     custom=TemplateExporter,
     html=HTMLExporter,
     slides=SlidesExporter,
     latex=LatexExporter,
+    pdf=PDFExporter,
     markdown=MarkdownExporter,
     python=PythonExporter,
     rst=RSTExporter,
 )
 
 def _make_exporter(name, E):
     """make an export_foo function from a short key and Exporter class E"""
     def _export(nb, **kw):
         return export(E, nb, **kw)
     _export.__doc__ = """Export a notebook object to {0} format""".format(name)
     return _export
     
 g = globals()
 
 for name, E in exporter_map.items():
     g['export_%s' % name] = DocDecorator(_make_exporter(name, E))
 
 @DocDecorator
 def export_by_name(format_name, nb, **kw):
     """
     Export a notebook object to a template type by its name.  Reflection
     (Inspect) is used to find the template's corresponding explicit export
     method defined in this module.  That method is then called directly.
     
     Parameters
     ----------
     format_name : str
         Name of the template style to export to.
     """
     
     function_name = "export_" + format_name.lower()
     
     if function_name in globals():
         return globals()[function_name](nb, **kw)
     else:
         raise ExporterNameError("template for `%s` not found" % function_name)
 
 
 def get_export_names():
     """Return a list of the currently supported export targets
 
     WARNING: API WILL CHANGE IN FUTURE RELEASES OF NBCONVERT"""
     return sorted(exporter_map.keys())

IPython/nbconvert/exporters/pdf.py

@@ -1,156 +1,141 b''
-"""
-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.
-#-----------------------------------------------------------------------------
+"""Export to PDF via latex"""
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 import subprocess
 import os
 import sys
 
-from IPython.utils.traitlets import Integer, List, Bool
+from IPython.utils.traitlets import Integer, List, Bool, Instance
+from IPython.utils.tempdir import TemporaryWorkingDirectory
+from .latex import LatexExporter
 
-from .base import PostProcessorBase
 
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
-class PDFPostProcessor(PostProcessorBase):
+class PDFExporter(LatexExporter):
     """Writer designed to write to PDF files"""
 
-    latex_count = Integer(3, config=True, help="""
-        How many times pdflatex will be called.
-        """)
+    latex_count = Integer(3, config=True,
+        help="How many times latex will be called."
+    )
+
+    latex_command = List([u"pdflatex", u"{filename}"], config=True, 
+        help="Shell command used to compile latex."
+    )
 
-    latex_command = List([u"pdflatex", u"{filename}"], config=True, help="""
-        Shell command used to compile PDF.""")
+    bib_command = List([u"bibtex", u"{filename}"], config=True,
+        help="Shell command used to run bibtex."
+    )
 
-    bib_command = List([u"bibtex", u"{filename}"], config=True, help="""
-        Shell command used to run bibtex.""")
+    verbose = Bool(False, config=True,
+        help="Whether to display the output of latex commands."
+    )
 
-    verbose = Bool(False, config=True, help="""
-        Whether or not to display the output of the compile call.
-        """)
+    temp_file_exts = List(['.aux', '.bbl', '.blg', '.idx', '.log', '.out'], config=True,
+        help="File extensions of temp files to remove after running."
+    )
 
-    temp_file_exts = List(['.aux', '.bbl', '.blg', '.idx', '.log', '.out'], 
-        config=True, help="""
-        Filename extensions of temp files to remove after running.
-        """)
-    pdf_open = Bool(False, config=True, help="""
-        Whether or not to open the pdf after the compile call.
-        """)
+    writer = Instance("IPython.nbconvert.writers.FilesWriter", args=())
 
     def run_command(self, command_list, filename, count, log_function):
         """Run command_list count times.
         
         Parameters
         ----------
         command_list : list
             A list of args to provide to Popen. Each element of this
             list will be interpolated with the filename to convert.
         filename : unicode
             The name of the file to convert.
         count : int
             How many times to run the command.
         
         Returns
         -------
-        continue : bool
+        success : bool
             A boolean indicating if the command was successful (True)
             or failed (False).
         """
         command = [c.format(filename=filename) for c in command_list]
         #In windows and python 2.x there is a bug in subprocess.Popen and
         # unicode commands are not supported
         if sys.platform == 'win32' and sys.version_info < (3,0):
             #We must use cp1252 encoding for calling subprocess.Popen
             #Note that sys.stdin.encoding and encoding.DEFAULT_ENCODING
             # could be different (cp437 in case of dos console)
             command = [c.encode('cp1252') for c in command]        
         times = 'time' if count == 1 else 'times'
         self.log.info("Running %s %i %s: %s", command_list[0], count, times, command)
         with open(os.devnull, 'rb') as null:
             stdout = subprocess.PIPE if not self.verbose else None
             for index in range(count):
                 p = subprocess.Popen(command, stdout=stdout, stdin=null)
                 out, err = p.communicate()
                 if p.returncode:
                     if self.verbose:
                         # verbose means I didn't capture stdout with PIPE,
                         # so it's already been displayed and `out` is None.
                         out = u''
                     else:
                         out = out.decode('utf-8', 'replace')
                     log_function(command, out)
                     return False # failure
         return True # success
 
     def run_latex(self, filename):
         """Run pdflatex self.latex_count times."""
 
         def log_error(command, out):
             self.log.critical(u"%s failed: %s\n%s", command[0], command, out)
 
         return self.run_command(self.latex_command, filename, 
             self.latex_count, log_error)
 
     def run_bib(self, filename):
         """Run bibtex self.latex_count times."""
         filename = os.path.splitext(filename)[0]
 
         def log_error(command, out):
             self.log.warn('%s had problems, most likely because there were no citations',
                 command[0])
             self.log.debug(u"%s output: %s\n%s", command[0], command, out)
 
         return self.run_command(self.bib_command, filename, 1, log_error)
 
     def clean_temp_files(self, filename):
         """Remove temporary files created by pdflatex/bibtex."""
         self.log.info("Removing temporary LaTeX files")
         filename = os.path.splitext(filename)[0]
         for ext in self.temp_file_exts:
             try:
                 os.remove(filename+ext)
             except OSError:
                 pass
 
-    def open_pdf(self, filename):
-        """Open the pdf in the default viewer."""
-        if sys.platform.startswith('darwin'):
-            subprocess.call(('open', filename))
-        elif os.name == 'nt':
-            os.startfile(filename)
-        elif os.name == 'posix':
-            subprocess.call(('xdg-open', filename))
-        return
-
-    def postprocess(self, filename):
-        """Build a PDF by running pdflatex and bibtex"""
+    def from_notebook_node(self, nb, resources=None, **kw):
+        latex, resources = super(PDFExporter, self).from_notebook_node(
+            nb, resources=resources, **kw
+        )
+        with TemporaryWorkingDirectory() as td:
+            notebook_name = "notebook"
+            tex_file = self.writer.write(latex, resources, notebook_name=notebook_name)
         self.log.info("Building PDF")
-        cont = self.run_latex(filename)
-        if cont:
-            cont = self.run_bib(filename)
-        else:
-            self.clean_temp_files(filename)
-            return
-        if cont:
-            cont = self.run_latex(filename)
-        self.clean_temp_files(filename)
-        filename = os.path.splitext(filename)[0]
-        if os.path.isfile(filename+'.pdf'):
+            rc = self.run_latex(tex_file)
+            if not rc:
+                rc = self.run_bib(tex_file)
+            if not rc:
+                rc = self.run_latex(tex_file)
+            
+            pdf_file = notebook_name + '.pdf'
+            if not os.path.isfile(pdf_file):
+                raise RuntimeError("PDF creating failed")
             self.log.info('PDF successfully created')
-            if self.pdf_open: 
-                self.log.info('Viewer called')
-                self.open_pdf(filename+'.pdf')
-        return
+            with open(pdf_file, 'rb') as f:
+                pdf_data = f.read()
+        
+        # convert output extension to pdf
+        # the writer above required it to be tex
+        resources['output_extension'] = 'pdf'
+        
+        return pdf_data, resources
  

IPython/nbconvert/nbconvertapp.py

@@ -1,323 +1,312 b''
 #!/usr/bin/env python
-"""NBConvert is a utility for conversion of .ipynb files.
+"""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
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
-# Stdlib imports
 from __future__ import print_function
 
 import logging
 import sys
 import os
 import glob
 
-# From IPython
 from IPython.core.application import BaseIPythonApplication, base_aliases, base_flags
 from IPython.core.profiledir import ProfileDir
 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 IPython.utils.text import dedent
 
 from .exporters.export import get_export_names, exporter_map
 from IPython.nbconvert import exporters, preprocessors, writers, postprocessors
 from .utils.base import NbConvertBase
 from .utils.exceptions import ConversionException
 
 #-----------------------------------------------------------------------------
 #Classes and functions
 #-----------------------------------------------------------------------------
 
 class DottedOrNone(DottedObjectName):
     """
     A string holding a valid dotted object name in Python, such as A.b3._c
     Also allows for None type."""
     
     default_value = u''
 
     def validate(self, obj, value):
         if value is not None and len(value) > 0:
             return super(DottedOrNone, self).validate(obj, value)
         else:
             return value
             
 nbconvert_aliases = {}
 nbconvert_aliases.update(base_aliases)
 nbconvert_aliases.update({
     'to' : 'NbConvertApp.export_format',
     'template' : 'TemplateExporter.template_file',
     'writer' : 'NbConvertApp.writer_class',
     'post': 'NbConvertApp.postprocessor_class',
     'output': 'NbConvertApp.output_base',
     'reveal-prefix': 'RevealHelpPreprocessor.url_prefix',
 })
 
 nbconvert_flags = {}
 nbconvert_flags.update(base_flags)
 nbconvert_flags.update({
     'stdout' : (
         {'NbConvertApp' : {'writer_class' : "StdoutWriter"}},
         "Write notebook output to stdout instead of files."
         )
 })
 
 
 class NbConvertApp(BaseIPythonApplication):
     """Application used to convert from notebook file type (``*.ipynb``)"""
 
     name = 'ipython-nbconvert'
     aliases = nbconvert_aliases
     flags = nbconvert_flags
     
     def _log_level_default(self):
         return logging.INFO
     
     def _classes_default(self):
         classes = [NbConvertBase, ProfileDir]
         for pkg in (exporters, preprocessors, writers, postprocessors):
             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.
 
         WARNING: THE COMMANDLINE INTERFACE MAY CHANGE IN FUTURE RELEASES.""")
 
     output_base = Unicode('', config=True, help='''overwrite base name use for output files.
             can only  be use when converting one notebook at a time.
             ''')
 
     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 output templates. LaTeX includes
         'basic', 'book', and 'article'.  HTML includes 'basic' and 'full'.  You 
         can specify the flavor of the format used.
 
         > ipython nbconvert --to html --template basic mynotebook.ipynb
         
         You can also pipe the output to stdout, rather than a file
         
         > ipython nbconvert mynotebook.ipynb --stdout
 
-        A post-processor can be used to compile a PDF
+        PDF is generated via latex
 
-        > ipython nbconvert mynotebook.ipynb --to latex --post PDF
+        > ipython nbconvert mynotebook.ipynb --to pdf
         
         You can get (and serve) a Reveal.js-powered slideshow
         
         > ipython nbconvert myslides.ipynb --to slides --post serve
         
         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',
                       '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.lower() in self.writer_aliases:
             new = self.writer_aliases[new.lower()]
         self.writer_factory = import_item(new)
 
     # Post-processor specific variables
     postprocessor = Instance('IPython.nbconvert.postprocessors.base.PostProcessorBase',  
                       help="""Instance of the PostProcessor class used to write the 
                       results of the conversion.""")
 
     postprocessor_class = DottedOrNone(config=True, 
                                     help="""PostProcessor class used to write the 
                                     results of the conversion""")
-    postprocessor_aliases = {'pdf': 'IPython.nbconvert.postprocessors.pdf.PDFPostProcessor',
-                              'serve': 'IPython.nbconvert.postprocessors.serve.ServePostProcessor'}
+    postprocessor_aliases = {'serve': 'IPython.nbconvert.postprocessors.serve.ServePostProcessor'}
     postprocessor_factory = Type()
 
     def _postprocessor_class_changed(self, name, old, new):
         if new.lower() in self.postprocessor_aliases:
             new = self.postprocessor_aliases[new.lower()]
         if new:
             self.postprocessor_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):
         self.init_syspath()
         super(NbConvertApp, self).initialize(argv)
         self.init_notebooks()
         self.init_writer()
         self.init_postprocessor()
 
 
 
     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'))
             if not globbed_files:
                 self.log.warn("pattern %r matched no files", pattern)
 
             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 init_postprocessor(self):
         """
         Initialize the postprocessor (which is stateless)
         """
         self._postprocessor_class_changed(None, self.postprocessor_class, 
             self.postprocessor_class)
         if self.postprocessor_factory:
             self.postprocessor = self.postprocessor_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
 
         if self.output_base != '' and len(self.notebooks) > 1:
             self.log.error(
             """UsageError: --output flag or `NbConvertApp.output_base` config option
             cannot be used when converting multiple notebooks.
             """)
             self.exit(1)
         
         exporter = exporter_map[self.export_format](config=self.config)
 
         for notebook_filename in self.notebooks:
             self.log.info("Converting notebook %s to %s", notebook_filename, self.export_format)
 
             # 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('.')]
             if self.output_base:
                 notebook_name = self.output_base
             resources = {}
             resources['unique_key'] = notebook_name
             resources['output_files_dir'] = '%s_files' % notebook_name
             self.log.info("Support files will be in %s", os.path.join(resources['output_files_dir'], ''))
 
             # Try to export
             try:
                 output, resources = exporter.from_filename(notebook_filename, resources=resources)
             except ConversionException as e:
                 self.log.error("Error while converting '%s'", notebook_filename,
                       exc_info=True)
                 self.exit(1)
             else:
                 write_resultes = self.writer.write(output, resources, notebook_name=notebook_name)
 
                 #Post-process if post processor has been defined.
                 if hasattr(self, 'postprocessor') and self.postprocessor:
                     self.postprocessor(write_resultes)
                 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/postprocessors/__init__.py

@@ -1,8 +1,7 b''
 from .base import PostProcessorBase
-from .pdf import PDFPostProcessor
 
 # protect against unavailable tornado
 try:
     from .serve import ServePostProcessor
 except ImportError:
     pass

IPython/nbconvert/tests/test_nbconvertapp.py

@@ -1,211 +1,202 b''
 # -*- coding: utf-8 -*- 
 """Test NbConvertApp"""
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2013 The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 import os
 import glob
 import sys
 
 from .base import TestsBase
+from ..postprocessors import PostProcessorBase
 
 import IPython.testing.tools as tt
 from IPython.testing import decorators as dec
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
+class DummyPost(PostProcessorBase):
+    def postprocess(self, filename):
+        print("Dummy:%s" % filename)
+
 class TestNbConvertApp(TestsBase):
     """Collection of NbConvertApp tests"""
 
 
     def test_notebook_help(self):
         """Will help show if no notebooks are specified?"""
         with self.create_temp_cwd():
             out, err = self.call('nbconvert --log-level 0', ignore_return_code=True)
             self.assertIn("see '--help-all'", out)
     
     def test_help_output(self):
         """ipython nbconvert --help-all works"""
         tt.help_all_output_test('nbconvert')
 
     def test_glob(self):
         """
         Do search patterns work for notebook names?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
             self.call('nbconvert --to python *.ipynb --log-level 0')
             assert os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_glob_subdir(self):
         """
         Do search patterns work for subdirectory notebook names?
         """
         with self.create_temp_cwd():
             self.copy_files_to(['notebook*.ipynb'], 'subdir/')
             self.call('nbconvert --to python --log-level 0 ' + 
                       os.path.join('subdir', '*.ipynb'))
             assert os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_explicit(self):
         """
         Do explicit notebook names work?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
             self.call('nbconvert --log-level 0 --to python notebook2')
             assert not os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     @dec.onlyif_cmds_exist('pdflatex')
     @dec.onlyif_cmds_exist('pandoc')
     def test_filename_spaces(self):
         """
         Generate PDFs with graphics if notebooks have spaces in the name?
         """
         with self.create_temp_cwd(['notebook2.ipynb']):
             os.rename('notebook2.ipynb', 'notebook with spaces.ipynb')
-            self.call('nbconvert --log-level 0 --to latex '
-                            '"notebook with spaces" --post PDF '
-                            '--PDFPostProcessor.verbose=True')
-            assert os.path.isfile('notebook with spaces.tex')
-            assert os.path.isdir('notebook with spaces_files')
+            self.call('nbconvert --log-level 0 --to pdf'
+                    ' "notebook with spaces"'
+                    ' --PDFExporter.latex_count=1'
+                    ' --PDFExporter.verbose=True'
+            )
             assert os.path.isfile('notebook with spaces.pdf')
 
-    @dec.onlyif_cmds_exist('pdflatex')
-    @dec.onlyif_cmds_exist('pandoc')
     def test_post_processor(self):
-        """
-        Do post processors work?
-        """
+        """Do post processors work?"""
         with self.create_temp_cwd(['notebook1.ipynb']):
-            self.call('nbconvert --log-level 0 --to latex notebook1 '
-                      '--post PDF --PDFPostProcessor.verbose=True')
-            assert os.path.isfile('notebook1.tex')
-            assert os.path.isfile('notebook1.pdf')
+            out, err = self.call('nbconvert --log-level 0 --to python notebook1 '
+                      '--post IPython.nbconvert.tests.test_nbconvertapp.DummyPost')
+            self.assertIn('Dummy:notebook1.py', out)
 
     @dec.onlyif_cmds_exist('pandoc')
     def test_spurious_cr(self):
         """Check for extra CR characters"""
         with self.create_temp_cwd(['notebook2.ipynb']):
             self.call('nbconvert --log-level 0 --to latex notebook2')
             assert os.path.isfile('notebook2.tex')
             with open('notebook2.tex') as f:
                 tex = f.read()
             self.call('nbconvert --log-level 0 --to html notebook2')
             assert os.path.isfile('notebook2.html')
             with open('notebook2.html') as f:
                 html = f.read()
         self.assertEqual(tex.count('\r'), tex.count('\r\n'))
         self.assertEqual(html.count('\r'), html.count('\r\n'))
 
     @dec.onlyif_cmds_exist('pandoc')
     def test_png_base64_html_ok(self):
         """Is embedded png data well formed in HTML?"""
         with self.create_temp_cwd(['notebook2.ipynb']):
             self.call('nbconvert --log-level 0 --to HTML '
                       'notebook2.ipynb --template full')
             assert os.path.isfile('notebook2.html')
             with open('notebook2.html') as f:
                 assert "data:image/png;base64,b'" not in f.read()
 
     @dec.onlyif_cmds_exist('pandoc')
     def test_template(self):
         """
         Do export templates work?
         """
         with self.create_temp_cwd(['notebook2.ipynb']):
             self.call('nbconvert --log-level 0 --to slides '  
                       'notebook2.ipynb')
             assert os.path.isfile('notebook2.slides.html')
             with open('notebook2.slides.html') as f:
                 assert '/reveal.css' in f.read()
 
 
     def test_glob_explicit(self):
         """
         Can a search pattern be used along with matching explicit notebook names?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
             self.call('nbconvert --log-level 0 --to python '
                       '*.ipynb notebook1.ipynb notebook2.ipynb')
             assert os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_explicit_glob(self):
         """
         Can explicit notebook names be used and then a matching search pattern?
         """
         with self.create_temp_cwd(['notebook*.ipynb']):
             self.call('nbconvert --log-level 0 --to=python '
                       'notebook1.ipynb notebook2.ipynb *.ipynb')
             assert os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
 
     def test_default_config(self):
         """
         Does the default config work?
         """
         with self.create_temp_cwd(['notebook*.ipynb', 'ipython_nbconvert_config.py']):
             self.call('nbconvert --log-level 0')
             assert os.path.isfile('notebook1.py')
             assert not os.path.isfile('notebook2.py')
 
 
     def test_override_config(self):
         """
         Can the default config be overriden?
         """
         with self.create_temp_cwd(['notebook*.ipynb',
                                    'ipython_nbconvert_config.py',
                                    'override.py']):
             self.call('nbconvert --log-level 0 --config="override.py"')
             assert not os.path.isfile('notebook1.py')
             assert os.path.isfile('notebook2.py')
 
     def test_accents_in_filename(self):
         """
         Can notebook names include accents?
         """
         with self.create_temp_cwd():
             self.create_empty_notebook(u'nb1_análisis.ipynb')
             self.call('nbconvert --log-level 0 --to python nb1_*')
             assert os.path.isfile(u'nb1_análisis.py')
     
     @dec.onlyif_cmds_exist('pdflatex', 'pandoc')
     def test_filename_accent_pdf(self):
         """
         Generate PDFs if notebooks have an accent in their name?
         """
         with self.create_temp_cwd():
             self.create_empty_notebook(u'nb1_análisis.ipynb')
-            self.call('nbconvert --log-level 0 --to latex '
-                            '"nb1_*" --post PDF '
-                            '--PDFPostProcessor.verbose=True')
-            assert os.path.isfile(u'nb1_análisis.tex')
+            self.call('nbconvert --log-level 0 --to pdf "nb1_*"'
+                    ' --PDFExporter.latex_count=1'
+                    ' --PDFExporter.verbose=True')
             assert os.path.isfile(u'nb1_análisis.pdf')
 
     def test_cwd_plugin(self):
         """
         Verify that an extension in the cwd can be imported.
         """
         with self.create_temp_cwd(['hello.py']):
             self.create_empty_notebook(u'empty.ipynb')
             self.call('nbconvert empty --to html --NbConvertApp.writer_class=\'hello.HelloWriter\'')
             assert os.path.isfile(u'hello.txt')

IPython/nbconvert/writers/files.py

@@ -1,115 +1,111 b''
-"""
-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.
-#-----------------------------------------------------------------------------
+"""Contains writer for writing nbconvert output to filesystem."""
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 import io
 import os
 import glob
 
 from IPython.utils.traitlets import Unicode
 from IPython.utils.path import link_or_copy
+from IPython.utils.py3compat import unicode_type
 
 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 _makedir(self, path):
         """Make a directory if it doesn't already exist"""
         if path and not os.path.isdir(path):
             self.log.info("Making directory %s", path)
             os.makedirs(path)
 
     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...
             """
 
             # Verify that a notebook name is provided.
             if notebook_name is None:
                 raise TypeError('notebook_name')
 
             # Pull the extension and subdir from the resources dict.
             output_extension = resources.get('output_extension', None)
 
             # Write all of the extracted resources to the destination directory.
             # NOTE: WE WRITE EVERYTHING AS-IF IT'S BINARY.  THE EXTRACT FIG
             # PREPROCESSOR 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)
                 self._makedir(path)
 
                 # Write file
                 self.log.debug("Writing %i bytes to support file %s", len(data), dest)
                 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)
                         self._makedir(path)
 
                         # Copy if destination is different.
                         if not os.path.normpath(dest) == os.path.normpath(matching_filename):
                             self.log.info("Linking %s -> %s", matching_filename, dest)
                             link_or_copy(matching_filename, dest)
 
             # Determine where to write conversion results.
             if output_extension is not None:
                 dest = notebook_name + '.' + output_extension
             else:
                 dest = notebook_name
             if self.build_directory:
                 dest = os.path.join(self.build_directory, dest)
 
             # Write conversion results.
             self.log.info("Writing %i bytes to %s", len(output), dest)
+            if isinstance(output, unicode_type):
             with io.open(dest, 'w', encoding='utf-8') as f:
                 f.write(output)
+            else:
+                with io.open(dest, 'wb') as f:
+                    f.write(output)
+                
             return dest