Add the . into file_extension

IPython/html/nbconvert/handlers.py

@@ -1,149 +1,149 b''
 """Tornado handlers for nbconvert."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import io
 import os
 import zipfile
 
 from tornado import web
 
 from ..base.handlers import (
     IPythonHandler, FilesRedirectHandler,
     notebook_path_regex, path_regex,
 )
 from IPython.nbformat import from_dict
 
 from IPython.utils.py3compat import cast_bytes
 
 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']
+    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):
         
         exporter = get_exporter(format, config=self.config, log=self.log)
         
         path = path.strip('/')
         model = self.contents_manager.get(path=path)
         name = model['name']
 
         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']
+            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()
         name = model.get('name', 'notebook.ipynb')
         nbnode = from_dict(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, 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),
     (r"/nbconvert/html%s" % path_regex, FilesRedirectHandler),
 ]

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

@@ -1,383 +1,383 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     'jquery',
     'base/js/namespace',
     'base/js/dialog',
     'base/js/utils',
     'notebook/js/tour',
     'bootstrap',
     'moment',
 ], function($, IPython, dialog, utils, tour, bootstrap, moment) {
     "use strict";
     
     var MenuBar = function (selector, options) {
         // Constructor
         //
         // A MenuBar Class to generate the menubar of IPython notebook
         //
         // Parameters:
         //  selector: string
         //  options: dictionary
         //      Dictionary of keyword arguments.
         //          notebook: Notebook instance
         //          contents: ContentManager instance
         //          layout_manager: LayoutManager instance
         //          events: $(Events) instance
         //          save_widget: SaveWidget instance
         //          quick_help: QuickHelp instance
         //          base_url : string
         //          notebook_path : string
         //          notebook_name : string
         options = options || {};
         this.base_url = options.base_url || utils.get_body_data("baseUrl");
         this.selector = selector;
         this.notebook = options.notebook;
         this.contents = options.contents;
         this.layout_manager = options.layout_manager;
         this.events = options.events;
         this.save_widget = options.save_widget;
         this.quick_help = options.quick_help;
 
         try {
             this.tour = new tour.Tour(this.notebook, this.events);
         } catch (e) {
             this.tour = undefined;
             console.log("Failed to instantiate Notebook Tour", e);
         }
 
         if (this.selector !== undefined) {
             this.element = $(selector);
             this.style();
             this.bind_events();
         }
     };
 
     // TODO: This has definitively nothing to do with style ...
     MenuBar.prototype.style = function () {
         var that = this;
         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 = that.notebook.get_selected_index();
                 that.notebook.select(i);
             }
         );
     };
 
     MenuBar.prototype._nbconvert = function (format, download) {
         download = download || false;
         var notebook_path = this.notebook.notebook_path;
         var url = utils.url_join_encode(
             this.base_url,
             'nbconvert',
             format,
             notebook_path
         ) + "?download=" + download.toString();
         
         var w = window.open()
         if (this.notebook.dirty) {
             this.notebook.save_notebook().then(function() {
                 w.location = url;
             });
         } else {
             w.location = url;
         }
     };
 
     MenuBar.prototype.bind_events = function () {
         //  File
         var that = this;
         this.element.find('#new_notebook').click(function () {
             var w = window.open();
             // Create a new notebook in the same path as the current
             // notebook's path.
             var parent = utils.url_path_split(that.notebook.notebook_path)[0];
             that.contents.new_untitled(parent, {type: "notebook"}).then(
                     function (data) {
                         w.location = utils.url_join_encode(
                                 that.base_url, 'notebooks', data.path
                             );
                     },
                     function(error) {
                         w.close();
                         dialog.modal({
                             title : 'Creating Notebook Failed',
                             body : "The error was: " + error.message,
                             buttons : {'OK' : {'class' : 'btn-primary'}}
                         });
                     }
                 );
         });
         this.element.find('#open_notebook').click(function () {
             var parent = utils.url_path_split(that.notebook.notebook_path)[0];
             window.open(utils.url_join_encode(that.base_url, 'tree', parent));
         });
         this.element.find('#copy_notebook').click(function () {
             that.notebook.copy_notebook();
             return false;
         });
         this.element.find('#download_ipynb').click(function () {
             var base_url = that.notebook.base_url;
             var notebook_path = that.notebook.notebook_path;
             if (that.notebook.dirty) {
                 that.notebook.save_notebook({async : false});
             }
             
             var url = utils.url_join_encode(base_url, 'files', notebook_path);
             window.open(url + '?download=1');
         });
         
         this.element.find('#print_preview').click(function () {
             that._nbconvert('html', false);
         });
 
         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 () {
             that.save_widget.rename_notebook({notebook: that.notebook});
         });
         this.element.find('#save_checkpoint').click(function () {
             that.notebook.save_checkpoint();
         });
         this.element.find('#restore_checkpoint').click(function () {
         });
         this.element.find('#trust_notebook').click(function () {
             that.notebook.trust_notebook();
         });
         this.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 () {
             var close_window = function () {
                 // allow closing of new tabs in Chromium, impossible in FF
                 window.open('', '_self', '');
                 window.close();
             };
             // finish with close on success or failure
             that.notebook.session.delete(close_window, close_window);
         });
         // Edit
         this.element.find('#cut_cell').click(function () {
             that.notebook.cut_cell();
         });
         this.element.find('#copy_cell').click(function () {
             that.notebook.copy_cell();
         });
         this.element.find('#delete_cell').click(function () {
             that.notebook.delete_cell();
         });
         this.element.find('#undelete_cell').click(function () {
             that.notebook.undelete_cell();
         });
         this.element.find('#split_cell').click(function () {
             that.notebook.split_cell();
         });
         this.element.find('#merge_cell_above').click(function () {
             that.notebook.merge_cell_above();
         });
         this.element.find('#merge_cell_below').click(function () {
             that.notebook.merge_cell_below();
         });
         this.element.find('#move_cell_up').click(function () {
             that.notebook.move_cell_up();
         });
         this.element.find('#move_cell_down').click(function () {
             that.notebook.move_cell_down();
         });
         this.element.find('#edit_nb_metadata').click(function () {
             that.notebook.edit_metadata({
                 notebook: that.notebook,
                 keyboard_manager: that.notebook.keyboard_manager});
         });
         
         // View
         this.element.find('#toggle_header').click(function () {
             $('div#header').toggle();
             that.layout_manager.do_resize();
         });
         this.element.find('#toggle_toolbar').click(function () {
             $('div#maintoolbar').toggle();
             that.layout_manager.do_resize();
         });
         // Insert
         this.element.find('#insert_cell_above').click(function () {
             that.notebook.insert_cell_above('code');
             that.notebook.select_prev();
         });
         this.element.find('#insert_cell_below').click(function () {
             that.notebook.insert_cell_below('code');
             that.notebook.select_next();
         });
         // Cell
         this.element.find('#run_cell').click(function () {
             that.notebook.execute_cell();
         });
         this.element.find('#run_cell_select_below').click(function () {
             that.notebook.execute_cell_and_select_below();
         });
         this.element.find('#run_cell_insert_below').click(function () {
             that.notebook.execute_cell_and_insert_below();
         });
         this.element.find('#run_all_cells').click(function () {
             that.notebook.execute_all_cells();
         });
         this.element.find('#run_all_cells_above').click(function () {
             that.notebook.execute_cells_above();
         });
         this.element.find('#run_all_cells_below').click(function () {
             that.notebook.execute_cells_below();
         });
         this.element.find('#to_code').click(function () {
             that.notebook.to_code();
         });
         this.element.find('#to_markdown').click(function () {
             that.notebook.to_markdown();
         });
         this.element.find('#to_raw').click(function () {
             that.notebook.to_raw();
         });
         
         this.element.find('#toggle_current_output').click(function () {
             that.notebook.toggle_output();
         });
         this.element.find('#toggle_current_output_scroll').click(function () {
             that.notebook.toggle_output_scroll();
         });
         this.element.find('#clear_current_output').click(function () {
             that.notebook.clear_output();
         });
         
         this.element.find('#toggle_all_output').click(function () {
             that.notebook.toggle_all_output();
         });
         this.element.find('#toggle_all_output_scroll').click(function () {
             that.notebook.toggle_all_output_scroll();
         });
         this.element.find('#clear_all_output').click(function () {
             that.notebook.clear_all_output();
         });
         
         // Kernel
         this.element.find('#int_kernel').click(function () {
             that.notebook.kernel.interrupt();
         });
         this.element.find('#restart_kernel').click(function () {
             that.notebook.restart_kernel();
         });
         this.element.find('#reconnect_kernel').click(function () {
             that.notebook.kernel.reconnect();
         });
         // Help
         if (this.tour) {
             this.element.find('#notebook_tour').click(function () {
                 that.tour.start();
             });
         } else {
             this.element.find('#notebook_tour').addClass("disabled");
         }
         this.element.find('#keyboard_shortcuts').click(function () {
             that.quick_help.show_keyboard_shortcuts();
         });
         
         this.update_restore_checkpoint(null);
         
         this.events.on('checkpoints_listed.Notebook', function (event, data) {
             that.update_restore_checkpoint(that.notebook.checkpoints);
         });
         
         this.events.on('checkpoint_created.Notebook', function (event, data) {
             that.update_restore_checkpoint(that.notebook.checkpoints);
         });
         
         this.events.on('notebook_loaded.Notebook', function() {
             var langinfo = that.notebook.metadata.language_info || {};
             that.update_nbconvert_script(langinfo);
         });
         
         this.events.on('kernel_ready.Kernel', function(event, data) {
             var langinfo = data.kernel.info_reply.language_info || {};
             that.update_nbconvert_script(langinfo);
         });
     };
 
     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;
         }
         
         var that = this;
         checkpoints.map(function (checkpoint) {
             var d = new Date(checkpoint.last_modified);
             ul.append(
                 $("<li/>").append(
                     $("<a/>")
                     .attr("href", "#")
                     .text(moment(d).format("LLLL"))
                     .click(function () {
                         that.notebook.restore_checkpoint_dialog(checkpoint);
                     })
                 )
             );
         });
     };
     
     MenuBar.prototype.update_nbconvert_script = function(langinfo) {
         // Set the 'Download as foo' menu option for the relevant language.
         var el = this.element.find('#download_script');
         var that = this;
         
         // Set menu entry text to e.g. "Python (.py)"
         var langname = (langinfo.name || 'Script')
         langname = langname.charAt(0).toUpperCase()+langname.substr(1) // Capitalise
-        el.find('a').text(langname + ' (.'+(langinfo.file_extension || 'txt')+')');
+        el.find('a').text(langname + ' ('+(langinfo.file_extension || 'txt')+')');
         
         // Unregister any previously registered handlers
         el.off('click');
         if (langinfo.nbconvert_exporter) {
             // Metadata specifies a specific exporter, e.g. 'python'
             el.click(function() {
                 that._nbconvert(langinfo.nbconvert_exporter, true);
             });
         } else {
             // Use generic 'script' exporter
             el.click(function() {
                 that._nbconvert('script', true);
             });
         }
     };
 
     // Backwards compatability.
     IPython.MenuBar = MenuBar;
 
     return {'MenuBar': MenuBar};
 });

IPython/kernel/zmq/ipkernel.py

@@ -1,330 +1,330 b''
 """The IPython kernel implementation"""
 
 import getpass
 import sys
 import traceback
 
 from IPython.core import release
 from IPython.html.widgets import Widget
 from IPython.utils.py3compat import builtin_mod, PY3
 from IPython.utils.tokenutil import token_at_cursor, line_at_cursor
 from IPython.utils.traitlets import Instance, Type, Any
 from IPython.utils.decorators import undoc
 
 from ..comm import CommManager
 from .kernelbase import Kernel as KernelBase
 from .serialize import serialize_object, unpack_apply_message
 from .zmqshell import ZMQInteractiveShell
 
 class IPythonKernel(KernelBase):
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
     shell_class = Type(ZMQInteractiveShell)
 
     user_module = Any()
     def _user_module_changed(self, name, old, new):
         if self.shell is not None:
             self.shell.user_module = new
 
     user_ns = Instance(dict, args=None, allow_none=True)
     def _user_ns_changed(self, name, old, new):
         if self.shell is not None:
             self.shell.user_ns = new
             self.shell.init_user_ns()
 
     # A reference to the Python builtin 'raw_input' function.
     # (i.e., __builtin__.raw_input for Python 2.7, builtins.input for Python 3)
     _sys_raw_input = Any()
     _sys_eval_input = Any()
 
     def __init__(self, **kwargs):
         super(IPythonKernel, self).__init__(**kwargs)
 
         # Initialize the InteractiveShell subclass
         self.shell = self.shell_class.instance(parent=self,
             profile_dir = self.profile_dir,
             user_module = self.user_module,
             user_ns     = self.user_ns,
             kernel      = self,
         )
         self.shell.displayhook.session = self.session
         self.shell.displayhook.pub_socket = self.iopub_socket
         self.shell.displayhook.topic = self._topic('execute_result')
         self.shell.display_pub.session = self.session
         self.shell.display_pub.pub_socket = self.iopub_socket
         self.shell.data_pub.session = self.session
         self.shell.data_pub.pub_socket = self.iopub_socket
 
         # TMP - hack while developing
         self.shell._reply_content = None
 
         self.comm_manager = CommManager(shell=self.shell, parent=self, 
                                         kernel=self)
         self.comm_manager.register_target('ipython.widget', Widget.handle_comm_opened)
 
         self.shell.configurables.append(self.comm_manager)
         comm_msg_types = [ 'comm_open', 'comm_msg', 'comm_close' ]
         for msg_type in comm_msg_types:
             self.shell_handlers[msg_type] = getattr(self.comm_manager, msg_type)
 
     # Kernel info fields
     implementation = 'ipython'
     implementation_version = release.version
     language = 'python'
     language_version = sys.version.split()[0]
     language_info = {'mimetype': 'text/x-python',
                      'codemirror_mode': {'name': 'ipython',
                                          'version': sys.version_info[0]},
                      'pygments_lexer': 'ipython%d' % (3 if PY3 else 2),
                      'nbconvert_exporter': 'python',
-                     'file_extension': 'py'
+                     'file_extension': '.py'
                     }
     @property
     def banner(self):
         return self.shell.banner
 
     def start(self):
         self.shell.exit_now = False
         super(IPythonKernel, self).start()
 
     def set_parent(self, ident, parent):
         """Overridden from parent to tell the display hook and output streams
         about the parent message.
         """
         super(IPythonKernel, self).set_parent(ident, parent)
         self.shell.set_parent(parent)
 
     def _forward_input(self, allow_stdin=False):
         """Forward raw_input and getpass to the current frontend.
 
         via input_request
         """
         self._allow_stdin = allow_stdin
 
         if PY3:
             self._sys_raw_input = builtin_mod.input
             builtin_mod.input = self.raw_input
         else:
             self._sys_raw_input = builtin_mod.raw_input
             self._sys_eval_input = builtin_mod.input
             builtin_mod.raw_input = self.raw_input
             builtin_mod.input = lambda prompt='': eval(self.raw_input(prompt))
         self._save_getpass = getpass.getpass
         getpass.getpass = self.getpass
 
     def _restore_input(self):
         """Restore raw_input, getpass"""
         if PY3:
             builtin_mod.input = self._sys_raw_input
         else:
             builtin_mod.raw_input = self._sys_raw_input
             builtin_mod.input = self._sys_eval_input
 
         getpass.getpass = self._save_getpass
 
     @property
     def execution_count(self):
         return self.shell.execution_count
 
     @execution_count.setter
     def execution_count(self, value):
         # Ignore the incrememnting done by KernelBase, in favour of our shell's
         # execution counter.
         pass
 
     def do_execute(self, code, silent, store_history=True,
                    user_expressions=None, allow_stdin=False):
         shell = self.shell # we'll need this a lot here
 
         self._forward_input(allow_stdin)
 
         reply_content = {}
         # FIXME: the shell calls the exception handler itself.
         shell._reply_content = None
         try:
             shell.run_cell(code, store_history=store_history, silent=silent)
         except:
             status = u'error'
             # FIXME: this code right now isn't being used yet by default,
             # because the run_cell() call above directly fires off exception
             # reporting.  This code, therefore, is only active in the scenario
             # where runlines itself has an unhandled exception.  We need to
             # uniformize this, for all exception construction to come from a
             # single location in the codbase.
             etype, evalue, tb = sys.exc_info()
             tb_list = traceback.format_exception(etype, evalue, tb)
             reply_content.update(shell._showtraceback(etype, evalue, tb_list))
         else:
             status = u'ok'
         finally:
             self._restore_input()
 
         reply_content[u'status'] = status
 
         # Return the execution counter so clients can display prompts
         reply_content['execution_count'] = shell.execution_count - 1
 
         # FIXME - fish exception info out of shell, possibly left there by
         # runlines.  We'll need to clean up this logic later.
         if shell._reply_content is not None:
             reply_content.update(shell._reply_content)
             e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method='execute')
             reply_content['engine_info'] = e_info
             # reset after use
             shell._reply_content = None
 
         if 'traceback' in reply_content:
             self.log.info("Exception in execute request:\n%s", '\n'.join(reply_content['traceback']))
 
 
         # At this point, we can tell whether the main code execution succeeded
         # or not.  If it did, we proceed to evaluate user_expressions
         if reply_content['status'] == 'ok':
             reply_content[u'user_expressions'] = \
                          shell.user_expressions(user_expressions or {})
         else:
             # If there was an error, don't even try to compute expressions
             reply_content[u'user_expressions'] = {}
 
         # Payloads should be retrieved regardless of outcome, so we can both
         # recover partial output (that could have been generated early in a
         # block, before an error) and clear the payload system always.
         reply_content[u'payload'] = shell.payload_manager.read_payload()
         # Be agressive about clearing the payload because we don't want
         # it to sit in memory until the next execute_request comes in.
         shell.payload_manager.clear_payload()
 
         return reply_content
 
     def do_complete(self, code, cursor_pos):
         # FIXME: IPython completers currently assume single line,
         # but completion messages give multi-line context
         # For now, extract line from cell, based on cursor_pos:
         if cursor_pos is None:
             cursor_pos = len(code)
         line, offset = line_at_cursor(code, cursor_pos)
         line_cursor = cursor_pos - offset
 
         txt, matches = self.shell.complete('', line, line_cursor)
         return {'matches' : matches,
                 'cursor_end' : cursor_pos,
                 'cursor_start' : cursor_pos - len(txt),
                 'metadata' : {},
                 'status' : 'ok'}
 
     def do_inspect(self, code, cursor_pos, detail_level=0):
         name = token_at_cursor(code, cursor_pos)
         info = self.shell.object_inspect(name)
 
         reply_content = {'status' : 'ok'}
         reply_content['data'] = data = {}
         reply_content['metadata'] = {}
         reply_content['found'] = info['found']
         if info['found']:
             info_text = self.shell.object_inspect_text(
                 name,
                 detail_level=detail_level,
             )
             data['text/plain'] = info_text
 
         return reply_content
 
     def do_history(self, hist_access_type, output, raw, session=None, start=None,
                    stop=None, n=None, pattern=None, unique=False):
         if hist_access_type == 'tail':
             hist = self.shell.history_manager.get_tail(n, raw=raw, output=output,
                                                             include_latest=True)
 
         elif hist_access_type == 'range':
             hist = self.shell.history_manager.get_range(session, start, stop,
                                                         raw=raw, output=output)
 
         elif hist_access_type == 'search':
             hist = self.shell.history_manager.search(
                 pattern, raw=raw, output=output, n=n, unique=unique)
         else:
             hist = []
 
         return {'history' : list(hist)}
 
     def do_shutdown(self, restart):
         self.shell.exit_now = True
         return dict(status='ok', restart=restart)
 
     def do_is_complete(self, code):
         status, indent_spaces = self.shell.input_transformer_manager.check_complete(code)
         r = {'status': status}
         if status == 'incomplete':
             r['indent'] = ' ' * indent_spaces
         return r
 
     def do_apply(self, content, bufs, msg_id, reply_metadata):
         shell = self.shell
         try:
             working = shell.user_ns
 
             prefix = "_"+str(msg_id).replace("-","")+"_"
 
             f,args,kwargs = unpack_apply_message(bufs, working, copy=False)
 
             fname = getattr(f, '__name__', 'f')
 
             fname = prefix+"f"
             argname = prefix+"args"
             kwargname = prefix+"kwargs"
             resultname = prefix+"result"
 
             ns = { fname : f, argname : args, kwargname : kwargs , resultname : None }
             # print ns
             working.update(ns)
             code = "%s = %s(*%s,**%s)" % (resultname, fname, argname, kwargname)
             try:
                 exec(code, shell.user_global_ns, shell.user_ns)
                 result = working.get(resultname)
             finally:
                 for key in ns:
                     working.pop(key)
 
             result_buf = serialize_object(result,
                 buffer_threshold=self.session.buffer_threshold,
                 item_threshold=self.session.item_threshold,
             )
 
         except:
             # invoke IPython traceback formatting
             shell.showtraceback()
             # FIXME - fish exception info out of shell, possibly left there by
             # run_code.  We'll need to clean up this logic later.
             reply_content = {}
             if shell._reply_content is not None:
                 reply_content.update(shell._reply_content)
                 e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method='apply')
                 reply_content['engine_info'] = e_info
                 # reset after use
                 shell._reply_content = None
 
             self.send_response(self.iopub_socket, u'error', reply_content,
                                 ident=self._topic('error'))
             self.log.info("Exception in apply request:\n%s", '\n'.join(reply_content['traceback']))
             result_buf = []
 
             if reply_content['ename'] == 'UnmetDependency':
                 reply_metadata['dependencies_met'] = False
         else:
             reply_content = {'status' : 'ok'}
 
         return reply_content, result_buf
 
     def do_clear(self):
         self.shell.reset(False)
         return dict(status='ok')
 
 
 # This exists only for backwards compatibility - use IPythonKernel instead
 
 @undoc
 class Kernel(IPythonKernel):
     def __init__(self, *args, **kwargs):
         import warnings
         warnings.warn('Kernel is a deprecated alias of IPython.kernel.zmq.ipkernel.IPythonKernel',
                       DeprecationWarning)
         super(Kernel, self).__init__(*args, **kwargs)
  No newline at end of file

IPython/nbconvert/exporters/exporter.py

@@ -1,259 +1,259 b''
 """This module defines a base Exporter class. For Jinja template-based export,
 see templateexporter.py.
 """
 
 
 from __future__ import print_function, absolute_import
 
 import io
 import os
 import copy
 import collections
 import datetime
 
 from IPython.config.configurable import LoggingConfigurable
 from IPython.config import Config
 from IPython import nbformat
 from IPython.utils.traitlets import MetaHasTraits, Unicode, List
 from IPython.utils.importstring import import_item
 from IPython.utils import text, py3compat
 
 
 class ResourcesDict(collections.defaultdict):
     def __missing__(self, key):
         return ''
 
 
 class Exporter(LoggingConfigurable):
     """
     Class containing methods that sequentially run a list of preprocessors on a 
     NotebookNode object and then return the modified NotebookNode object and 
     accompanying resources dict.
     """
 
     file_extension = Unicode(
-        'txt', config=True,
+        '.txt', config=True,
         help="Extension of the file that should be written to disk"
         )
 
     # MIME type of the result file, for HTTP response headers.
     # This is *not* a traitlet, because we want to be able to access it from
     # the class, not just on instances.
     output_mimetype = ''
 
     #Configurability, allows the user to easily add filters and preprocessors.
     preprocessors = List(config=True,
         help="""List of preprocessors, by name or namespace, to enable.""")
 
     _preprocessors = List()
 
     default_preprocessors = List(['IPython.nbconvert.preprocessors.coalesce_streams',
                                   'IPython.nbconvert.preprocessors.SVG2PDFPreprocessor',
                                   'IPython.nbconvert.preprocessors.ExtractOutputPreprocessor',
                                   'IPython.nbconvert.preprocessors.CSSHTMLHeaderPreprocessor',
                                   'IPython.nbconvert.preprocessors.RevealHelpPreprocessor',
                                   'IPython.nbconvert.preprocessors.LatexPreprocessor',
                                   'IPython.nbconvert.preprocessors.ClearOutputPreprocessor',
                                   'IPython.nbconvert.preprocessors.ExecutePreprocessor',
                                   'IPython.nbconvert.preprocessors.HighlightMagicsPreprocessor'],
         config=True,
         help="""List of preprocessors available by default, by name, namespace, 
         instance, or type.""")
 
 
     def __init__(self, config=None, **kw):
         """
         Public constructor
 
         Parameters
         ----------
         config : config
             User configuration instance.
         """
         with_default_config = self.default_config
         if config:
             with_default_config.merge(config)
         
         super(Exporter, self).__init__(config=with_default_config, **kw)
 
         self._init_preprocessors()
 
 
     @property
     def default_config(self):
         return Config()
 
     def from_notebook_node(self, nb, resources=None, **kw):
         """
         Convert a notebook from a notebook node instance.
 
         Parameters
         ----------
         nb : :class:`~IPython.nbformat.NotebookNode`
           Notebook node (dict-like with attr-access)
         resources : dict
           Additional resources that can be accessed read/write by
           preprocessors and filters.
         **kw
           Ignored (?)
         """
         nb_copy = copy.deepcopy(nb)
         resources = self._init_resources(resources)
         
         if 'language' in nb['metadata']:
             resources['language'] = nb['metadata']['language'].lower()
 
         # Preprocess
         nb_copy, resources = self._preprocess(nb_copy, resources)
 
         return nb_copy, resources
 
 
     def from_filename(self, filename, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
 
         Parameters
         ----------
         filename : str
             Full filename of the notebook file to open and convert.
         """
 
         # Pull the metadata from the filesystem.
         if resources is None:
             resources = ResourcesDict()
         if not 'metadata' in resources or resources['metadata'] == '':
             resources['metadata'] = ResourcesDict()
         basename = os.path.basename(filename)
         notebook_name = basename[:basename.rfind('.')]
         resources['metadata']['name'] = notebook_name
 
         modified_date = datetime.datetime.fromtimestamp(os.path.getmtime(filename))
         resources['metadata']['modified_date'] = modified_date.strftime(text.date_format)
 
         with io.open(filename, encoding='utf-8') as f:
             return self.from_notebook_node(nbformat.read(f, as_version=4), resources=resources, **kw)
 
 
     def from_file(self, file_stream, resources=None, **kw):
         """
         Convert a notebook from a notebook file.
 
         Parameters
         ----------
         file_stream : file-like object
             Notebook file-like object to convert.
         """
         return self.from_notebook_node(nbformat.read(file_stream, as_version=4), resources=resources, **kw)
 
 
     def register_preprocessor(self, preprocessor, enabled=False):
         """
         Register a preprocessor.
         Preprocessors are classes that act upon the notebook before it is
         passed into the Jinja templating engine.  preprocessors are also
         capable of passing additional information to the Jinja
         templating engine.
 
         Parameters
         ----------
         preprocessor : preprocessor
         """
         if preprocessor is None:
             raise TypeError('preprocessor')
         isclass = isinstance(preprocessor, type)
         constructed = not isclass
 
         # Handle preprocessor's registration based on it's type
         if constructed and isinstance(preprocessor, py3compat.string_types):
             # Preprocessor is a string, import the namespace and recursively call
             # this register_preprocessor method
             preprocessor_cls = import_item(preprocessor)
             return self.register_preprocessor(preprocessor_cls, enabled)
 
         if constructed and hasattr(preprocessor, '__call__'):
             # Preprocessor is a function, no need to construct it.
             # Register and return the preprocessor.
             if enabled:
                 preprocessor.enabled = True
             self._preprocessors.append(preprocessor)
             return preprocessor
 
         elif isclass and isinstance(preprocessor, MetaHasTraits):
             # Preprocessor is configurable.  Make sure to pass in new default for 
             # the enabled flag if one was specified.
             self.register_preprocessor(preprocessor(parent=self), enabled)
 
         elif isclass:
             # Preprocessor is not configurable, construct it
             self.register_preprocessor(preprocessor(), enabled)
 
         else:
             # Preprocessor is an instance of something without a __call__ 
             # attribute.  
             raise TypeError('preprocessor')
 
 
     def _init_preprocessors(self):
         """
         Register all of the preprocessors needed for this exporter, disabled
         unless specified explicitly.
         """
         self._preprocessors = []
 
         # Load default preprocessors (not necessarly enabled by default).
         for preprocessor in self.default_preprocessors:
             self.register_preprocessor(preprocessor)
 
         # Load user-specified preprocessors.  Enable by default.
         for preprocessor in self.preprocessors:
             self.register_preprocessor(preprocessor, enabled=True)
 
 
     def _init_resources(self, resources):
 
         #Make sure the resources dict is of ResourcesDict type.
         if resources is None:
             resources = ResourcesDict()
         if not isinstance(resources, ResourcesDict):
             new_resources = ResourcesDict()
             new_resources.update(resources)
             resources = new_resources
 
         #Make sure the metadata extension exists in resources
         if 'metadata' in resources:
             if not isinstance(resources['metadata'], ResourcesDict):
                 resources['metadata'] = ResourcesDict(resources['metadata'])
         else:
             resources['metadata'] = ResourcesDict()
             if not resources['metadata']['name']:
                 resources['metadata']['name'] = 'Notebook'
 
         #Set the output extension
         resources['output_extension'] = self.file_extension
         return resources
 
 
     def _preprocess(self, nb, resources):
         """
         Preprocess the notebook before passing it into the Jinja engine.
         To preprocess the notebook is to apply all of the
 
         Parameters
         ----------
         nb : notebook node
             notebook that is being exported.
         resources : a dict of additional resources that
             can be accessed read/write by preprocessors
         """
 
         # Do a copy.deepcopy first,
         # we are never safe enough with what the preprocessors could do.
         nbc =  copy.deepcopy(nb)
         resc = copy.deepcopy(resources)
 
         #Run each preprocessor on the notebook.  Carry the output along
         #to each preprocessor
         for preprocessor in self._preprocessors:
             nbc, resc = preprocessor(nbc, resc)
         return nbc, resc

IPython/nbconvert/exporters/html.py

@@ -1,66 +1,66 b''
 """HTML Exporter class"""
 
 #-----------------------------------------------------------------------------
 # 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 os
 
 from IPython.nbconvert.filters.highlight import Highlight2HTML
 from IPython.config import Config
 
 from .templateexporter import TemplateExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class HTMLExporter(TemplateExporter):
     """
     Exports a basic HTML document.  This exporter assists with the export of
     HTML.  Inherit from it if you are writing your own HTML template and need
     custom preprocessors/filters.  If you don't need custom preprocessors/
     filters, just change the 'template_file' config option.  
     """
     
     def _file_extension_default(self):
-        return 'html'
+        return '.html'
 
     def _default_template_path_default(self):
         return os.path.join("..", "templates", "html")
 
     def _template_file_default(self):
         return 'full'
     
     output_mimetype = 'text/html'
     
     @property
     def default_config(self):
         c = Config({
             'NbConvertBase': {
                 'display_data_priority' : ['text/javascript', 'text/html', 'application/pdf', 'image/svg+xml', 'text/latex', 'image/png', 'image/jpeg', 'text/plain']
                 },
             'CSSHTMLHeaderPreprocessor':{
                 'enabled':True
                 },
             'HighlightMagicsPreprocessor': {
                 'enabled':True
                 }
             })
         c.merge(super(HTMLExporter,self).default_config)
         return c
 
     def from_notebook_node(self, nb, resources=None, **kw):
         langinfo = nb.metadata.get('language_info', {})
         lexer = langinfo.get('pygments_lexer', langinfo.get('name', None))
         self.register_filter('highlight_code',
                              Highlight2HTML(pygments_lexer=lexer, parent=self))
         return super(HTMLExporter, self).from_notebook_node(nb, resources, **kw)

IPython/nbconvert/exporters/pdf.py

@@ -1,141 +1,141 b''
 """Export to PDF via latex"""
 
 # 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, Instance
 from IPython.utils.tempdir import TemporaryWorkingDirectory
 from .latex import LatexExporter
 
 
 class PDFExporter(LatexExporter):
     """Writer designed to write to PDF files"""
 
     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."
     )
 
     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."
     )
 
     temp_file_exts = List(['.aux', '.bbl', '.blg', '.idx', '.log', '.out'], config=True,
         help="File extensions of temp files to remove after running."
     )
     
     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
         -------
         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 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")
             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')
             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'
+        resources['output_extension'] = '.pdf'
         
         return pdf_data, resources
     

IPython/nbconvert/exporters/python.py

@@ -1,31 +1,31 b''
 """Python script Exporter class"""
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from .templateexporter import TemplateExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class PythonExporter(TemplateExporter):
     """
     Exports a Python code file.
     """
     def _file_extension_default(self):
-        return 'py'
+        return '.py'
 
     def _template_file_default(self):
         return 'python'
 
     output_mimetype = 'text/x-python'

IPython/nbconvert/exporters/rst.py

@@ -1,40 +1,40 b''
 """restructuredText Exporter class"""
 
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from IPython.config import Config
 
 from .templateexporter import TemplateExporter
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class RSTExporter(TemplateExporter):
     """
     Exports restructured text documents.
     """
     
     def _file_extension_default(self):
-        return 'rst'
+        return '.rst'
 
     def _template_file_default(self):
         return 'rst'
 
     output_mimetype = 'text/restructuredtext'
 
     @property
     def default_config(self):
         c = Config({'ExtractOutputPreprocessor':{'enabled':True}})
         c.merge(super(RSTExporter,self).default_config)
         return c

IPython/nbconvert/exporters/script.py

@@ -1,14 +1,14 b''
 """Generic script exporter class for any kernel language"""
 
 from .templateexporter import TemplateExporter
 
 class ScriptExporter(TemplateExporter):
     def _template_file_default(self):
         return 'script'
 
     def from_notebook_node(self, nb, resources=None, **kw):
         langinfo = nb.metadata.get('language_info', {})
-        self.file_extension = langinfo.get('file_extension', 'txt')
+        self.file_extension = langinfo.get('file_extension', '.txt')
         self.output_mimetype = langinfo.get('mimetype', 'text/plain')
 
         return super(ScriptExporter, self).from_notebook_node(nb, resources, **kw)

IPython/nbconvert/nbconvertapp.py

@@ -1,324 +1,324 b''
 #!/usr/bin/env python
 """NbConvert is a utility for conversion of .ipynb files.
 
 Command-line interface for the NbConvert conversion utility.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from __future__ import print_function
 
 import logging
 import sys
 import os
 import glob
 
 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 .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',
     'nbformat': 'NotebookExporter.nbformat_version',
 })
 
 nbconvert_flags = {}
 nbconvert_flags.update(base_flags)
 nbconvert_flags.update({
     'execute' : (
         {'ExecutePreprocessor' : {'enabled' : True}},
         "Execute the notebook prior to export."
         ),
     '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 used 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.ipynb
 
         Both HTML and LaTeX support multiple output templates. LaTeX includes
         'base', 'article' and 'report'.  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
 
         PDF is generated via latex
 
         > 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 = {'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:
                 # strip duplicate extension from output_base, to avoid Basname.ext.ext
                 if getattr(exporter, 'file_extension', False):
                     base, ext = os.path.splitext(self.output_base)
-                    if ext == '.' + exporter.file_extension:
+                    if ext == exporter.file_extension:
                         self.output_base = base
                 notebook_name = self.output_base
             resources = {}
             resources['profile_dir'] = self.profile_dir.location
             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:
                 if 'output_suffix' in resources and not self.output_base:
                     notebook_name += resources['output_suffix']
                 write_results = 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_results)
                 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/writers/files.py

@@ -1,111 +1,111 b''
 """Contains writer for writing nbconvert output to filesystem."""
 
 # 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, ensure_dir_exists
 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:
             ensure_dir_exists(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:
             self.log.info("Making directory %s", path)
             ensure_dir_exists(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, matching_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
+                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

IPython/nbconvert/writers/tests/test_files.py

@@ -1,203 +1,203 b''
 """
 Module with tests for files
 """
 
 #-----------------------------------------------------------------------------
 # 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 sys
 import os
 
 from ...tests.base import TestsBase
 from ..files import FilesWriter
 from IPython.utils.py3compat import PY3
 
 if PY3:
     from io import StringIO
 else:
     from StringIO import StringIO
 
 
 #-----------------------------------------------------------------------------
 # Class
 #-----------------------------------------------------------------------------
 
 class Testfiles(TestsBase):
     """Contains test functions for files.py"""
 
     def test_basic_output(self):
         """Is FilesWriter basic output correct?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create the resoruces dictionary
             res = {}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             with open('z', 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
     def test_ext(self):
         """Does the FilesWriter add the correct extension to the output?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create the resoruces dictionary
-            res = {'output_extension': 'txt'}
+            res = {'output_extension': '.txt'}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             assert os.path.isfile('z.txt')
             with open('z.txt', 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
 
     def test_extract(self):
         """Can FilesWriter write extracted figures correctly?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create the resoruces dictionary
             res = {'outputs': {os.path.join('z_files', 'a'): b'b'}}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             with open('z', 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
             # Check the output of the extracted file
             extracted_file_dest = os.path.join('z_files', 'a')
             assert os.path.isfile(extracted_file_dest)
             with open(extracted_file_dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, 'b')
 
 
     def test_builddir(self):
         """Can FilesWriter write to a build dir correctly?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create the resoruces dictionary
             res = {'outputs': {os.path.join('z_files', 'a'): b'b'}}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.build_directory = u'build'
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             assert os.path.isdir(writer.build_directory)
             dest = os.path.join(writer.build_directory, 'z')
             with open(dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
             # Check the output of the extracted file
             extracted_file_dest = os.path.join(writer.build_directory, 'z_files', 'a')
             assert os.path.isfile(extracted_file_dest)
             with open(extracted_file_dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, 'b')
 
 
     def test_links(self):
         """Can the FilesWriter handle linked files correctly?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create test file
             os.mkdir('sub')
             with open(os.path.join('sub', 'c'), 'w') as f:
                 f.write('d')
 
             # Create the resoruces dictionary
             res = {}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.files = [os.path.join('sub', 'c')]
             writer.build_directory = u'build'
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             assert os.path.isdir(writer.build_directory)
             dest = os.path.join(writer.build_directory, 'z')
             with open(dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
             # Check to make sure the linked file was copied
             path = os.path.join(writer.build_directory, 'sub')
             assert os.path.isdir(path)
             dest = os.path.join(path, 'c')
             assert os.path.isfile(dest)
             with open(dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, 'd')
 
     def test_glob(self):
         """Can the FilesWriter handle globbed files correctly?"""
 
         # Work in a temporary directory.
         with self.create_temp_cwd():
 
             # Create test files
             os.mkdir('sub')
             with open(os.path.join('sub', 'c'), 'w') as f:
                 f.write('e')
             with open(os.path.join('sub', 'd'), 'w') as f:
                 f.write('e')
 
             # Create the resoruces dictionary
             res = {}
 
             # Create files writer, test output
             writer = FilesWriter()
             writer.files = ['sub/*']
             writer.build_directory = u'build'
             writer.write(u'y', res, notebook_name="z")
 
             # Check the output of the file
             assert os.path.isdir(writer.build_directory)
             dest = os.path.join(writer.build_directory, 'z')
             with open(dest, 'r') as f:
                 output = f.read()
                 self.assertEqual(output, u'y')
 
             # Check to make sure the globbed files were copied
             path = os.path.join(writer.build_directory, 'sub')
             assert os.path.isdir(path)
             for filename in ['c', 'd']:
                 dest = os.path.join(path, filename)
                 assert os.path.isfile(dest)
                 with open(dest, 'r') as f:
                     output = f.read()
                     self.assertEqual(output, 'e')