Adding tracebacks, evalue and etype to the nbformat and notebook.

IPython/frontend/html/notebook/handlers.py

@@ -1,212 +1,195 b''
 """Tornado handlers for the notebook."""
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import json
 import logging
 import os
 import urllib
 
 from tornado import web
 from tornado import websocket
 
 try:
     from docutils.core import publish_string
 except ImportError:
     publish_string = None
 
 
 #-----------------------------------------------------------------------------
 # Top-level handlers
 #-----------------------------------------------------------------------------
 
 
 class NBBrowserHandler(web.RequestHandler):
     def get(self):
         nbm = self.application.notebook_manager
         project = nbm.notebook_dir
         self.render('nbbrowser.html', project=project)
 
 
 class NewHandler(web.RequestHandler):
     def get(self):
         notebook_id = self.application.notebook_manager.new_notebook()
         self.render('notebook.html', notebook_id=notebook_id)
 
 
 class NamedNotebookHandler(web.RequestHandler):
     def get(self, notebook_id):
         nbm = self.application.notebook_manager
         if not nbm.notebook_exists(notebook_id):
             raise web.HTTPError(404)
         self.render('notebook.html', notebook_id=notebook_id)
 
 
 #-----------------------------------------------------------------------------
 # Kernel handlers
 #-----------------------------------------------------------------------------
 
 
 class MainKernelHandler(web.RequestHandler):
 
     def get(self):
         rkm = self.application.routing_kernel_manager
         self.finish(json.dumps(rkm.kernel_ids))
 
     def post(self):
         rkm = self.application.routing_kernel_manager
         notebook_id = self.get_argument('notebook', default=None)
         kernel_id = rkm.start_kernel(notebook_id)
         self.set_header('Location', '/'+kernel_id)
         self.finish(json.dumps(kernel_id))
 
 
 class KernelHandler(web.RequestHandler):
 
     SUPPORTED_METHODS = ('DELETE')
 
     def delete(self, kernel_id):
         rkm = self.application.routing_kernel_manager
         rkm.kill_kernel(kernel_id)
         self.set_status(204)
         self.finish()
 
 
 class KernelActionHandler(web.RequestHandler):
 
     def post(self, kernel_id, action):
         rkm = self.application.routing_kernel_manager
         if action == 'interrupt':
             rkm.interrupt_kernel(kernel_id)
             self.set_status(204)
         if action == 'restart':
             new_kernel_id = rkm.restart_kernel(kernel_id)
             self.write(json.dumps(new_kernel_id))
         self.finish()
 
 
 class ZMQStreamHandler(websocket.WebSocketHandler):
 
     def initialize(self, stream_name):
         self.stream_name = stream_name
 
     def open(self, kernel_id):
         rkm = self.application.routing_kernel_manager
         self.router = rkm.get_router(kernel_id, self.stream_name)
         self.client_id = self.router.register_client(self)
 
     def on_message(self, msg):
         self.router.forward_msg(self.client_id, msg)
 
     def on_close(self):
         self.router.unregister_client(self.client_id)
 
 
 #-----------------------------------------------------------------------------
 # Notebook web service handlers
 #-----------------------------------------------------------------------------
 
 class NotebookRootHandler(web.RequestHandler):
 
     def get(self):
         nbm = self.application.notebook_manager
         files = nbm.list_notebooks()
         self.finish(json.dumps(files))
 
     def post(self):
         nbm = self.application.notebook_manager
         body = self.request.body.strip()
         format = self.get_argument('format', default='json')
         name = self.get_argument('name', default=None)
         if body:
             notebook_id = nbm.save_new_notebook(body, name=name, format=format)
         else:
             notebook_id = nbm.new_notebook()
         self.set_header('Location', '/'+notebook_id)
         self.finish(json.dumps(notebook_id))
 
 
 class NotebookHandler(web.RequestHandler):
 
     SUPPORTED_METHODS = ('GET', 'PUT', 'DELETE')
 
     def get(self, notebook_id):
         nbm = self.application.notebook_manager
         format = self.get_argument('format', default='json')
         last_mod, name, data = nbm.get_notebook(notebook_id, format)
         if format == u'json':
             self.set_header('Content-Type', 'application/json')
             self.set_header('Content-Disposition','attachment; filename=%s.json' % name)
         elif format == u'xml':
             self.set_header('Content-Type', 'application/xml')
             self.set_header('Content-Disposition','attachment; filename=%s.ipynb' % name)
         elif format == u'py':
             self.set_header('Content-Type', 'application/x-python')
             self.set_header('Content-Disposition','attachment; filename=%s.py' % name)
         self.set_header('Last-Modified', last_mod)
         self.finish(data)
 
     def put(self, notebook_id):
         nbm = self.application.notebook_manager
         format = self.get_argument('format', default='json')
         name = self.get_argument('name', default=None)
         nbm.save_notebook(notebook_id, self.request.body, name=name, format=format)
         self.set_status(204)
         self.finish()
 
     def delete(self, notebook_id):
         nbm = self.application.notebook_manager
         nbm.delete_notebook(notebook_id)
         self.set_status(204)
         self.finish()
 
 #-----------------------------------------------------------------------------
 # RST web service handlers
 #-----------------------------------------------------------------------------
 
-_rst_header = """========
-Heading1
-========
-
-Heading2
-========
-
-Heading3
---------
-
-Heading4
-^^^^^^^^
-
-"""
 
 class RSTHandler(web.RequestHandler):
 
     def post(self):
         if publish_string is None:
             raise web.HTTPError(503)
         body = self.request.body.strip()
-        source = _rst_header + body
-        template_path=os.path.join(os.path.dirname(__file__), u'templates', u'rst_template.html')
+        source = body
+        # template_path=os.path.join(os.path.dirname(__file__), u'templates', u'rst_template.html')
         print template_path
         defaults = {'file_insertion_enabled': 0,
                     'raw_enabled': 0,
                     '_disable_config': 1,
                     'stylesheet_path': 0,
-                    'initial_header_level': 3,
-                    'template': template_path
+                    # 'template': template_path
         }
         try:
             html = publish_string(source, writer_name='html',
                                   settings_overrides=defaults
             )
         except:
             raise web.HTTPError(400)
         print html
-#        html = '\n'.join(html.split('\n')[7:-3])
-#        print html
         self.set_header('Content-Type', 'text/html')
         self.finish(html)
 
 

IPython/frontend/html/notebook/static/js/codecell.js

@@ -1,421 +1,421 b''
 
 //============================================================================
 // CodeCell
 //============================================================================
 
 var IPython = (function (IPython) {
 
     var utils = IPython.utils;
 
     var CodeCell = function (notebook) {
         this.code_mirror = null;
         this.input_prompt_number = ' ';
         this.is_completing = false;
         this.completion_cursor = null;
         this.outputs = [];
         this.collapsed = false;
         IPython.Cell.apply(this, arguments);
     };
 
 
     CodeCell.prototype = new IPython.Cell();
 
 
     CodeCell.prototype.create_element = function () {
         var cell =  $('<div></div>').addClass('cell border-box-sizing code_cell vbox');
         var input = $('<div></div>').addClass('input hbox');
         input.append($('<div/>').addClass('prompt input_prompt'));
         var input_area = $('<div/>').addClass('input_area box-flex1');
         this.code_mirror = CodeMirror(input_area.get(0), {
             indentUnit : 4,
             mode: 'python',
             theme: 'ipython',
             onKeyEvent: $.proxy(this.handle_codemirror_keyevent,this)
         });
         input.append(input_area);
         var output = $('<div></div>').addClass('output vbox');
         cell.append(input).append(output);
         this.element = cell;
         this.collapse()
     };
 
 
     CodeCell.prototype.handle_codemirror_keyevent = function (editor, event) {
         // This method gets called in CodeMirror's onKeyDown/onKeyPress handlers and
         // is used to provide custom key handling. Its return value is used to determine
         // if CodeMirror should ignore the event: true = ignore, false = don't ignore.
         if (event.keyCode === 13 && event.shiftKey) {
             // Always ignore shift-enter in CodeMirror as we handle it.
             return true;
         } else if (event.keyCode === 9) {
             var cur = editor.getCursor();
             var pre_cursor = editor.getRange({line:cur.line,ch:0},cur).trim();
             if (pre_cursor === "") {
                 // Don't autocomplete if the part of the line before the cursor is empty.
                 // In this case, let CodeMirror handle indentation.
                 return false;
             } else {
                 // Autocomplete the current line.
                 event.stop();
                 var line = editor.getLine(cur.line);
                 this.is_completing = true;
                 this.completion_cursor = cur;
                 IPython.notebook.complete_cell(this, line, cur.ch);
                 return true;
             }
         } else if (event.keyCode === 8 && event.type == 'keydown') {
             // If backspace and the line ends with 4 spaces, remove them.
             var cur = editor.getCursor();
             var line = editor.getLine(cur.line);
             var ending = line.slice(-4);
             if (ending === '    ') {
                 editor.replaceRange('',
                     {line: cur.line, ch: cur.ch-4},
                     {line: cur.line, ch: cur.ch}
                 );
                 event.stop();
                 return true;
             } else {
                 return false;
             };
         } else {
             if (this.is_completing && this.completion_cursor !== editor.getCursor()) {
                 this.is_completing = false;
                 this.completion_cursor = null;
             }
             return false;
         };
     };
 
 
     CodeCell.prototype.finish_completing = function (matched_text, matches) {
         if (!this.is_completing || matches.length === 0) {return;}
         // console.log("Got matches", matched_text, matches);
 
         var that = this;
         var cur = this.completion_cursor;
         var complete = $('<div/>').addClass('completions');
         var select = $('<select/>').attr('multiple','true');
         for (var i=0; i<matches.length; ++i) {
             select.append($('<option/>').text(matches[i]));
         }
         select.children().first().attr('selected','true');
         select.attr('size',Math.min(10,matches.length));
         var pos = this.code_mirror.cursorCoords();
         complete.css('left',pos.x+'px');
         complete.css('top',pos.yBot+'px');
         complete.append(select);
 
         $('body').append(complete);
         var done = false;
 
         var insert = function (selected_text) {
             that.code_mirror.replaceRange(
                 selected_text,
                 {line: cur.line, ch: (cur.ch-matched_text.length)},
                 {line: cur.line, ch: cur.ch}
             );
         };
 
         var close = function () {
             if (done) return;
             done = true;
             complete.remove();
             that.is_completing = false;
             that.completion_cursor = null;
         };
 
         var pick = function () {
             insert(select.val()[0]);
             close();
             setTimeout(function(){that.code_mirror.focus();}, 50);
         };
 
         select.blur(close);
         select.keydown(function (event) {
             var code = event.which;
             if (code === 13 || code === 32) {
                 // Pressing SPACE or ENTER will cause a pick
                 event.stopPropagation();
                 event.preventDefault();
                 pick();
             } else if (code === 38 || code === 40) {
                 // We don't want the document keydown handler to handle UP/DOWN,
                 // but we want the default action.
                 event.stopPropagation();
             } else {
                 // All other key presses simple exit completion.
                 event.stopPropagation();
                 event.preventDefault();
                 close();
                 that.code_mirror.focus();
             }
         });
         // Double click also causes a pick.
         select.dblclick(pick);
         select.focus();
     };
 
 
     CodeCell.prototype.select = function () {
         IPython.Cell.prototype.select.apply(this);
         // Todo: this dance is needed because as of CodeMirror 2.12, focus is
         // not causing the cursor to blink if the editor is empty initially.
         // While this seems to fix the issue, this should be fixed
         // in CodeMirror proper.
         var s = this.code_mirror.getValue();
         if (s === '') this.code_mirror.setValue('.');
         this.code_mirror.focus();
         if (s === '') this.code_mirror.setValue('');
     };
 
 
     CodeCell.prototype.append_output = function (json) {
         this.expand();
         if (json.output_type === 'pyout') {
             this.append_pyout(json);
         } else if (json.output_type === 'pyerr') {
             this.append_pyerr(json);
         } else if (json.output_type === 'display_data') {
             this.append_display_data(json);
         } else if (json.output_type === 'stream') {
             this.append_stream(json);
         };
         this.outputs.push(json);
     };
 
 
     CodeCell.prototype.append_pyout = function (json) {
         n = json.prompt_number || ' ';
         var toinsert = $("<div/>").addClass("output_pyout hbox");
         toinsert.append($('<div/>').
             addClass('prompt output_prompt').
             html('Out[' + n + ']:')
         );
         this.append_mime_type(json, toinsert).addClass('output_area');
         toinsert.children().last().addClass("box_flex1 pyout_area");
         this.element.find("div.output").append(toinsert);
         // If we just output latex, typeset it.
         if (json.latex !== undefined) {
             MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
         };
     };
 
 
     CodeCell.prototype.append_pyerr = function (json) {
         var tb = json.traceback;
-        if (tb !== undefined) {
+        if (tb !== undefined && tb.length > 0) {
             var s = '';
             var len = tb.length;
             for (var i=0; i<len; i++) {
                 s = s + tb[i] + '\n';
             }
             s = s + '\n';
             this.append_text(s).addClass('output_area');
         };
     };
 
 
     CodeCell.prototype.append_stream = function (json) {
         this.append_text(json.text).addClass('output_area');
     };
 
 
     CodeCell.prototype.append_display_data = function (json) {
         this.append_mime_type(json).addClass('output_area');
     };
 
 
     CodeCell.prototype.append_mime_type = function (json, element) {
         if (json.html !== undefined) {
             this.append_html(json.html, element);
         } else if (json.latex !== undefined) {
             this.append_latex(json.latex, element);
             // If it is undefined, then we just appended to div.output, which
             // makes the latex visible and we can typeset it. The typesetting
             // has to be done after the latex is on the page.
             if (element === undefined) {
                 MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
             };
         } else if (json.svg !== undefined) {
             this.append_svg(json.svg, element);
         } else if (json.png !== undefined) {
             this.append_png(json.png, element);
         } else if (json.jpeg !== undefined) {
             this.append_jpeg(json.jpeg, element);
         } else if (json.text !== undefined) {
             this.append_text(json.text, element);
         };
         return element;
     };
 
 
     CodeCell.prototype.append_html = function (html, element) {
         element = element || this.element.find("div.output");
         var toinsert = $("<div/>").addClass("output_html");
         toinsert.append(html);
         element.append(toinsert);
         return element;
     }
 
 
     CodeCell.prototype.append_text = function (data, element) {
         element = element || this.element.find("div.output");
         var toinsert = $("<div/>").addClass("output_stream");
-        toinsert.append($("<pre/>").html(utils.fixConsole(data)));
+        toinsert.append($("<pre/>").html(data));
         element.append(toinsert);
         return element;
     };
 
 
     CodeCell.prototype.append_svg = function (svg, element) {
         element = element || this.element.find("div.output");
         var toinsert = $("<div/>").addClass("output_svg");
         toinsert.append(svg);
         element.append(toinsert);
         return element;
     };
 
 
     CodeCell.prototype.append_png = function (png, element) {
         element = element || this.element.find("div.output");
         var toinsert = $("<div/>").addClass("output_png");
         toinsert.append($("<img/>").attr('src','data:image/png;base64,'+png));
         element.append(toinsert);
         return element;
     };
 
 
     CodeCell.prototype.append_jpeg = function (jpeg, element) {
         element = element || this.element.find("div.output");
         var toinsert = $("<div/>").addClass("output_jpeg");
         toinsert.append($("<img/>").attr('src','data:image/jpeg;base64,'+jpeg));
         element.append(toinsert);
         return element;
     };
 
 
     CodeCell.prototype.append_latex = function (latex, element) {
         // This method cannot do the typesetting because the latex first has to
         // be on the page.
         element = element || this.element.find("div.output");
         var toinsert = $("<div/>").addClass("output_latex");
         toinsert.append(latex);
         element.append(toinsert);
         return element;
     }
 
 
     CodeCell.prototype.clear_output = function () {
         this.element.find("div.output").html("");
         this.outputs = [];
     };
 
 
     CodeCell.prototype.clear_input = function () {
         this.code_mirror.setValue('');
     };
 
 
     CodeCell.prototype.collapse = function () {
         if (!this.collapsed) {
             this.element.find('div.output').hide();
             this.collapsed = true;
         };
     };
 
 
     CodeCell.prototype.expand = function () {
         if (this.collapsed) {
             this.element.find('div.output').show();
             this.collapsed = false;
         };
     };
 
 
     CodeCell.prototype.set_input_prompt = function (number) {
         var n = number || ' ';
         this.input_prompt_number = n
         this.element.find('div.input_prompt').html('In&nbsp;[' + n + ']:');
     };
 
 
     CodeCell.prototype.get_code = function () {
         return this.code_mirror.getValue();
     };
 
 
     CodeCell.prototype.set_code = function (code) {
         return this.code_mirror.setValue(code);
     };
 
 
     CodeCell.prototype.at_top = function () {
         var cursor = this.code_mirror.getCursor();
         if (cursor.line === 0) {
             return true;
         } else {
             return false;
         }
     };
 
 
     CodeCell.prototype.at_bottom = function () {
         var cursor = this.code_mirror.getCursor();
         if (cursor.line === (this.code_mirror.lineCount()-1)) {
             return true;
         } else {
             return false;
         }
     };
 
 
     CodeCell.prototype.fromJSON = function (data) {
         // console.log('Import from JSON:', data);
         if (data.cell_type === 'code') {
             if (data.input !== undefined) {
                 this.set_code(data.input);
             }
             if (data.prompt_number !== undefined) {
                 this.set_input_prompt(data.prompt_number);
             } else {
                 this.set_input_prompt();
             };
             var len = data.outputs.length;
             for (var i=0; i<len; i++) {
                 this.append_output(data.outputs[i]);
             };
             if (data.collapsed !== undefined) {
                 if (data.collapsed) {
                     this.collapse();
                 };
             };
         };
     };
 
 
     CodeCell.prototype.toJSON = function () {
         var data = {};
         data.input = this.get_code();
         data.cell_type = 'code';
         if (this.input_prompt_number !== ' ') {
             data.prompt_number = this.input_prompt_number
         };
         var outputs = [];
         var len = this.outputs.length;
         for (var i=0; i<len; i++) {
             outputs[i] = this.outputs[i];
         };
         data.outputs = outputs;
         data.language = 'python';
         data.collapsed = this.collapsed;
         // console.log('Export to JSON:',data);
         return data;
     };
 
 
     IPython.CodeCell = CodeCell;
 
     return IPython;
 }(IPython));
 

IPython/frontend/html/notebook/static/js/notebook.js

@@ -1,737 +1,740 b''
 
 //============================================================================
 // Notebook
 //============================================================================
 
 var IPython = (function (IPython) {
 
     var utils = IPython.utils;
 
     var Notebook = function (selector) {
         this.element = $(selector);
         this.element.scroll();
         this.element.data("notebook", this);
         this.next_prompt_number = 1;
         this.kernel = null;
         this.msg_cell_map = {};
         this.style();
         this.create_elements();
         this.bind_events();
     };
 
 
     Notebook.prototype.style = function () {
         $('div#notebook').addClass('border-box-sizing');
     };
 
 
     Notebook.prototype.create_elements = function () {
         // We add this end_space div to the end of the notebook div to:
         // i) provide a margin between the last cell and the end of the notebook
         // ii) to prevent the div from scrolling up when the last cell is being
         // edited, but is too low on the page, which browsers will do automatically.
         this.element.append($('<div class="end_space"></div>').height(50));
         $('div#notebook').addClass('border-box-sizing');
     };
 
 
     Notebook.prototype.bind_events = function () {
         var that = this;
         $(document).keydown(function (event) {
             // console.log(event);
             if (event.which === 38) {
                 var cell = that.selected_cell();
                 if (cell.at_top()) {
                     event.preventDefault();
                     that.select_prev();
                 };
             } else if (event.which === 40) {
                 var cell = that.selected_cell();
                 if (cell.at_bottom()) {
                     event.preventDefault();
                     that.select_next();
                 };
             } else if (event.which === 13 && event.shiftKey) {
                 that.execute_selected_cell();
                 return false;
             } else if (event.which === 13 && event.ctrlKey) {
                 that.execute_selected_cell({terminal:true});
                 return false;
             };
         });
 
         this.element.bind('collapse_pager', function () {
             var app_height = $('div#main_app').height(); // content height
             var splitter_height = $('div#pager_splitter').outerHeight(true);
             var new_height = app_height - splitter_height;
             that.element.animate({height : new_height + 'px'}, 'fast');
         });
 
         this.element.bind('expand_pager', function () {
             var app_height = $('div#main_app').height(); // content height
             var splitter_height = $('div#pager_splitter').outerHeight(true);
             var pager_height = $('div#pager').outerHeight(true);
             var new_height = app_height - pager_height - splitter_height; 
             that.element.animate({height : new_height + 'px'}, 'fast');
         });
 
         this.element.bind('collapse_left_panel', function () {
             var splitter_width = $('div#left_panel_splitter').outerWidth(true);
             var new_margin = splitter_width;
             $('div#notebook_panel').animate({marginLeft : new_margin + 'px'}, 'fast');
         });
 
         this.element.bind('expand_left_panel', function () {
             var splitter_width = $('div#left_panel_splitter').outerWidth(true);
             var left_panel_width = IPython.left_panel.width;
             var new_margin = splitter_width + left_panel_width;
             $('div#notebook_panel').animate({marginLeft : new_margin + 'px'}, 'fast');
         });
     };
 
 
     Notebook.prototype.scroll_to_bottom = function () {
         this.element.animate({scrollTop:this.element.get(0).scrollHeight}, 0);
     };
 
 
     Notebook.prototype.scroll_to_top = function () {
         this.element.animate({scrollTop:0}, 0);
     };
 
 
     // Cell indexing, retrieval, etc.
 
 
     Notebook.prototype.cell_elements = function () {
         return this.element.children("div.cell");
     }
 
 
     Notebook.prototype.ncells = function (cell) {
         return this.cell_elements().length;
     }
 
 
     // TODO: we are often calling cells as cells()[i], which we should optimize
     // to cells(i) or a new method.
     Notebook.prototype.cells = function () {
         return this.cell_elements().toArray().map(function (e) {
             return $(e).data("cell");
         });
     }
 
 
     Notebook.prototype.find_cell_index = function (cell) {
         var result = null;
         this.cell_elements().filter(function (index) {
             if ($(this).data("cell") === cell) {
                 result = index;
             };
         });
         return result;
     };
 
 
     Notebook.prototype.index_or_selected = function (index) {
         return index || this.selected_index() || 0;
     }
 
 
     Notebook.prototype.select = function (index) {
         if (index !== undefined && index >= 0 && index < this.ncells()) {
             if (this.selected_index() !== null) {
                 this.selected_cell().unselect();
             };
             this.cells()[index].select();
             if (index === (this.ncells()-1)) {
                 this.scroll_to_bottom();
             };
         };
         return this;
     };
 
 
     Notebook.prototype.select_next = function () {
         var index = this.selected_index();
         if (index !== null && index >= 0 && (index+1) < this.ncells()) {
             this.select(index+1);
         };
         return this;
     };
 
 
     Notebook.prototype.select_prev = function () {
         var index = this.selected_index();
         if (index !== null && index >= 0 && (index-1) < this.ncells()) {
             this.select(index-1);
         };
         return this;
     };
 
 
     Notebook.prototype.selected_index = function () {
         var result = null;
         this.cell_elements().filter(function (index) {
             if ($(this).data("cell").selected === true) {
                 result = index;
             };
         });
         return result;
     };
 
 
     Notebook.prototype.cell_for_msg = function (msg_id) {
         var cell_id = this.msg_cell_map[msg_id];
         var result = null;
         this.cell_elements().filter(function (index) {
             cell = $(this).data("cell");
             if (cell.cell_id === cell_id) {
                 result = cell;
             };
         });
         return result;
     };
 
 
     Notebook.prototype.selected_cell = function () {
         return this.cell_elements().eq(this.selected_index()).data("cell");
     }
 
 
     // Cell insertion, deletion and moving.
 
 
     Notebook.prototype.delete_cell = function (index) {
         var i = index || this.selected_index();
         if (i !== null && i >= 0 && i < this.ncells()) {
             this.cell_elements().eq(i).remove();
             if (i === (this.ncells())) {
                 this.select(i-1);
             } else {
                 this.select(i);
             };
         };
         return this;
     };
 
 
     Notebook.prototype.append_cell = function (cell) {
         this.element.find('div.end_space').before(cell.element);
         return this;
     };
 
 
     Notebook.prototype.insert_cell_after = function (cell, index) {
         var ncells = this.ncells();
         if (ncells === 0) {
             this.append_cell(cell);
             return this;
         };
         if (index >= 0 && index < ncells) {
             this.cell_elements().eq(index).after(cell.element);
         };
         return this
     };
 
 
     Notebook.prototype.insert_cell_before = function (cell, index) {
         var ncells = this.ncells();
         if (ncells === 0) {
             this.append_cell(cell);
             return this;
         };
         if (index >= 0 && index < ncells) {
             this.cell_elements().eq(index).before(cell.element);
         };
         return this;
     };
 
 
     Notebook.prototype.move_cell_up = function (index) {
         var i = index || this.selected_index();
         if (i !== null && i < this.ncells() && i > 0) {
             var pivot = this.cell_elements().eq(i-1);
             var tomove = this.cell_elements().eq(i);
             if (pivot !== null && tomove !== null) {
                 tomove.detach();
                 pivot.before(tomove);
                 this.select(i-1);
             };
         };
         return this;
     }
 
 
     Notebook.prototype.move_cell_down = function (index) {
         var i = index || this.selected_index();
         if (i !== null && i < (this.ncells()-1) && i >= 0) {
             var pivot = this.cell_elements().eq(i+1)
             var tomove = this.cell_elements().eq(i)
             if (pivot !== null && tomove !== null) {
                 tomove.detach();
                 pivot.after(tomove);
                 this.select(i+1);
             };
         };
         return this;
     }
 
 
     Notebook.prototype.sort_cells = function () {
         var ncells = this.ncells();
         var sindex = this.selected_index();
         var swapped;
         do {
             swapped = false
             for (var i=1; i<ncells; i++) {
                 current = this.cell_elements().eq(i).data("cell");
                 previous = this.cell_elements().eq(i-1).data("cell");
                 if (previous.input_prompt_number > current.input_prompt_number) {
                     this.move_cell_up(i);
                     swapped = true;
                 };
             };
         } while (swapped);
         this.select(sindex);
         return this;
     };
 
 
     Notebook.prototype.insert_code_cell_before = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.CodeCell(this);
         cell.set_input_prompt();
         this.insert_cell_before(cell, i);
         this.select(this.find_cell_index(cell));
         return cell;
     }
 
 
     Notebook.prototype.insert_code_cell_after = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.CodeCell(this);
         cell.set_input_prompt();
         this.insert_cell_after(cell, i);
         this.select(this.find_cell_index(cell));
         return cell;
     }
 
 
     Notebook.prototype.insert_html_cell_before = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.HTMLCell(this);
         cell.config_mathjax();
         this.insert_cell_before(cell, i);
         this.select(this.find_cell_index(cell));
         return cell;
     }
 
 
     Notebook.prototype.insert_html_cell_after = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.HTMLCell(this);
         cell.config_mathjax();
         this.insert_cell_after(cell, i);
         this.select(this.find_cell_index(cell));
         return cell;
     }
 
 
     Notebook.prototype.insert_markdown_cell_before = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.MarkdownCell(this);
         cell.config_mathjax();
         this.insert_cell_before(cell, i);
         this.select(this.find_cell_index(cell));
         return cell;
     }
 
 
     Notebook.prototype.insert_markdown_cell_after = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var cell = new IPython.MarkdownCell(this);
         cell.config_mathjax();
         this.insert_cell_after(cell, i);
         this.select(this.find_cell_index(cell));
         return cell;
     }
 
 
     Notebook.prototype.to_code = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var source_element = this.cell_elements().eq(i);
         var source_cell = source_element.data("cell");
         if (source_cell instanceof IPython.HTMLCell || 
             source_cell instanceof IPython.MarkdownCell) {
             this.insert_code_cell_after(i);
             var target_cell = this.cells()[i+1];
             target_cell.set_code(source_cell.get_source());
             source_element.remove();
         };
     };
 
 
     Notebook.prototype.to_markdown = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var source_element = this.cell_elements().eq(i);
         var source_cell = source_element.data("cell");
         var target_cell = null;
         if (source_cell instanceof IPython.CodeCell) {
             this.insert_markdown_cell_after(i);
             var target_cell = this.cells()[i+1];
             var text = source_cell.get_code();
         } else if (source_cell instanceof IPython.HTMLCell) {
             this.insert_markdown_cell_after(i);
             var target_cell = this.cells()[i+1];
             var text = source_cell.get_source();
             if (text === source_cell.placeholder) {
                 text = target_cell.placeholder;
             }
         }
         if (target_cell !== null) {
             if (text === "") {text = target_cell.placeholder;};
             target_cell.set_source(text);
             source_element.remove();
             target_cell.edit();
         }
     };
 
 
     Notebook.prototype.to_html = function (index) {
         // TODO: Bounds check for i
         var i = this.index_or_selected(index);
         var source_element = this.cell_elements().eq(i);
         var source_cell = source_element.data("cell");
         var target_cell = null;
         if (source_cell instanceof IPython.CodeCell) {
             this.insert_html_cell_after(i);
             var target_cell = this.cells()[i+1];
             var text = source_cell.get_code();
         } else if (source_cell instanceof IPython.MarkdownCell) {
             this.insert_html_cell_after(i);
             var target_cell = this.cells()[i+1];
             var text = source_cell.get_source();
             if (text === source_cell.placeholder) {
                 text = target_cell.placeholder;
             }
         }
         if (target_cell !== null) {
             if (text === "") {text = target_cell.placeholder;};
             target_cell.set_source(text);
             source_element.remove();
             target_cell.edit();
         }
     };
 
 
     // Cell collapsing
 
     Notebook.prototype.collapse = function (index) {
         var i = this.index_or_selected(index);
         this.cells()[i].collapse();
     };
 
 
     Notebook.prototype.expand = function (index) {
         var i = this.index_or_selected(index);
         this.cells()[i].expand();
     };
 
 
     Notebook.prototype.set_autoindent = function (state) {
         var cells = this.cells();
         len = cells.length;
         for (var i=0; i<len; i++) {
             cells[i].set_autoindent(state)
         };
     };
 
     // Kernel related things
 
     Notebook.prototype.start_kernel = function () {
         this.kernel = new IPython.Kernel();
         var notebook_id = IPython.save_widget.get_notebook_id();
         this.kernel.start_kernel(notebook_id, $.proxy(this.kernel_started, this));
     };
 
 
     Notebook.prototype.handle_shell_reply = function (e) {
         reply = $.parseJSON(e.data);
         var header = reply.header;
         var content = reply.content;
         var msg_type = header.msg_type;
         // console.log(reply);
         var cell = this.cell_for_msg(reply.parent_header.msg_id);
         if (msg_type === "execute_reply") {
             cell.set_input_prompt(content.execution_count);
         } else if (msg_type === "complete_reply") {
             cell.finish_completing(content.matched_text, content.matches);
         };
         var payload = content.payload || [];
         this.handle_payload(cell, payload);
     };
 
 
     Notebook.prototype.handle_payload = function (cell, payload) {
         var l = payload.length;
         for (var i=0; i<l; i++) {
             if (payload[i].source === 'IPython.zmq.page.page') {
                 IPython.pager.clear();
                 IPython.pager.expand();
                 IPython.pager.append_text(payload[i].text);
             } else if (payload[i].source === 'IPython.zmq.zmqshell.ZMQInteractiveShell.set_next_input') {
                 var index = this.find_cell_index(cell);
                 var new_cell = this.insert_code_cell_after(index);
                 new_cell.set_code(payload[i].text);
             }
         };
     };
 
 
     Notebook.prototype.handle_iopub_reply = function (e) {
         reply = $.parseJSON(e.data);
         var content = reply.content;
         // console.log(reply);
         var msg_type = reply.header.msg_type;
         var cell = this.cell_for_msg(reply.parent_header.msg_id);
         var output_types = ['stream','display_data','pyout','pyerr'];
         if (output_types.indexOf(msg_type) >= 0) {
             this.handle_output(cell, msg_type, content);
         } else if (msg_type === "status") {
             if (content.execution_state === "busy") {
                 IPython.kernel_status_widget.status_busy();
             } else if (content.execution_state === "idle") {
                 IPython.kernel_status_widget.status_idle();
             };
         }
     };
 
 
     Notebook.prototype.handle_output = function (cell, msg_type, content) {
         var json = {};
         json.output_type = msg_type;
         if (msg_type === "stream") {
-            json.text = content.data + '\n';
+            json.text = utils.fixConsole(content.data + '\n');
         } else if (msg_type === "display_data") {
             json = this.convert_mime_types(json, content.data);
         } else if (msg_type === "pyout") {
             json.prompt_number = content.execution_count;
             json = this.convert_mime_types(json, content.data);
         } else if (msg_type === "pyerr") {
             json.ename = content.ename;
             json.evalue = content.evalue;
-            json.traceback = content.traceback;
+            var traceback = [];
+            for (var i=0; i<content.traceback.length; i++) {
+                traceback.push(utils.fixConsole(content.traceback[i]));
+            }
+            json.traceback = traceback;
         };
         cell.append_output(json);
     };
 
 
     Notebook.prototype.convert_mime_types = function (json, data) {
         if (data['text/plain'] !== undefined) {
-            json.text = data['text/plain'];
+            json.text = utils.fixConsole(data['text/plain']);
         };
         if (data['text/html'] !== undefined) {
             json.html = data['text/html'];
         };
         if (data['image/svg+xml'] !== undefined) {
             json.svg = data['image/svg+xml'];
         };
         if (data['image/png'] !== undefined) {
             json.png = data['image/png'];
         };
         if (data['image/jpeg'] !== undefined) {
             json.jpeg = data['image/jpeg'];
         };
         if (data['text/latex'] !== undefined) {
             json.latex = data['text/latex'];
         };
         if (data['application/json'] !== undefined) {
             json.json = data['application/json'];
         };
         if (data['application/javascript'] !== undefined) {
             json.javascript = data['application/javascript'];
         }
         return json;    
     };
 
     Notebook.prototype.kernel_started = function () {
         console.log("Kernel started: ", this.kernel.kernel_id);
         this.kernel.shell_channel.onmessage = $.proxy(this.handle_shell_reply,this);
         this.kernel.iopub_channel.onmessage = $.proxy(this.handle_iopub_reply,this);
     };
 
 
     Notebook.prototype.execute_selected_cell = function (options) {
         // add_new: should a new cell be added if we are at the end of the nb
         // terminal: execute in terminal mode, which stays in the current cell
         default_options = {terminal: false, add_new: true}
         $.extend(default_options, options)
         var that = this;
         var cell = that.selected_cell();
         var cell_index = that.find_cell_index(cell);
         if (cell instanceof IPython.CodeCell) {
             cell.clear_output();
             var code = cell.get_code();
             var msg_id = that.kernel.execute(cell.get_code());
             that.msg_cell_map[msg_id] = cell.cell_id;
         } else if (cell instanceof IPython.HTMLCell) {
             cell.render();
         }
         if (default_options.terminal) {
             cell.clear_input();
         } else {
             if ((cell_index === (that.ncells()-1)) && default_options.add_new) {
                 that.insert_code_cell_after();
                 // If we are adding a new cell at the end, scroll down to show it.
                 that.scroll_to_bottom();
             } else {
                 that.select(cell_index+1);
             };
         };
     };
 
 
     Notebook.prototype.execute_all_cells = function () {
         var ncells = this.ncells();
         for (var i=0; i<ncells; i++) {
             this.select(i);
             this.execute_selected_cell({add_new:false});
         };
         this.scroll_to_bottom();
     };
 
 
     Notebook.prototype.complete_cell = function (cell, line, cursor_pos) {
         var msg_id = this.kernel.complete(line, cursor_pos);
         this.msg_cell_map[msg_id] = cell.cell_id;
     };
 
     // Persistance and loading
 
 
     Notebook.prototype.fromJSON = function (data) {
         var ncells = this.ncells();
         for (var i=0; i<ncells; i++) {
             // Always delete cell 0 as they get renumbered as they are deleted.
             this.delete_cell(0);
         };
         // Only handle 1 worksheet for now.
         var worksheet = data.worksheets[0];
         if (worksheet !== undefined) {
             var new_cells = worksheet.cells;
             ncells = new_cells.length;
             var cell_data = null;
             var new_cell = null;
             for (var i=0; i<ncells; i++) {
                 cell_data = new_cells[i];
                 if (cell_data.cell_type == 'code') {
                     new_cell = this.insert_code_cell_after();
                     new_cell.fromJSON(cell_data);
                 } else if (cell_data.cell_type === 'html') {
                     new_cell = this.insert_html_cell_after();
                     new_cell.fromJSON(cell_data);
                 } else if (cell_data.cell_type === 'markdown') {
                     new_cell = this.insert_markdown_cell_after();
                     new_cell.fromJSON(cell_data);
                 };
             };          
         };
     };
 
 
     Notebook.prototype.toJSON = function () {
         var cells = this.cells();
         var ncells = cells.length;
         cell_array = new Array(ncells);
         for (var i=0; i<ncells; i++) {
             cell_array[i] = cells[i].toJSON();
         };
         data = {
             // Only handle 1 worksheet for now.
             worksheets : [{cells:cell_array}]
         }
         return data
     };
 
     Notebook.prototype.save_notebook = function () {
         if (IPython.save_widget.test_notebook_name()) {
             var notebook_id = IPython.save_widget.get_notebook_id();
             var nbname = IPython.save_widget.get_notebook_name();
             // We may want to move the name/id/nbformat logic inside toJSON?
             var data = this.toJSON();
             data.name = nbname;
             data.nbformat = 2;
             data.id = notebook_id
             // We do the call with settings so we can set cache to false.
             var settings = {
                 processData : false,
                 cache : false,
                 type : "PUT",
                 data : JSON.stringify(data),
                 headers : {'Content-Type': 'application/json'},
                 success : $.proxy(this.notebook_saved,this)
             };
             IPython.save_widget.status_saving();
             $.ajax("/notebooks/" + notebook_id, settings);
         };
     };
 
 
     Notebook.prototype.notebook_saved = function (data, status, xhr) {
         setTimeout($.proxy(IPython.save_widget.status_save,IPython.save_widget),500);
-//        IPython.save_widget.status_save();
     }
 
 
     Notebook.prototype.load_notebook = function (callback) {
         var that = this;
         var notebook_id = IPython.save_widget.get_notebook_id();
         // We do the call with settings so we can set cache to false.
         var settings = {
             processData : false,
             cache : false,
             type : "GET",
             dataType : "json",
             success : function (data, status, xhr) {
                 that.notebook_loaded(data, status, xhr);
                 if (callback !== undefined) {
                     callback();
                 };
             }
         };
         IPython.save_widget.status_loading();
         $.ajax("/notebooks/" + notebook_id, settings);
     }
 
 
     Notebook.prototype.notebook_loaded = function (data, status, xhr) {
         this.fromJSON(data);
         if (this.ncells() === 0) {
             this.insert_code_cell_after();
         };
         IPython.save_widget.status_save();
         IPython.save_widget.set_notebook_name(data.name);
         this.start_kernel();
         // fromJSON always selects the last cell inserted. We need to wait
         // until that is done before scrolling to the top.
         setTimeout(function () {
             IPython.notebook.select(0);
             IPython.notebook.scroll_to_top();
         }, 50);
     };
 
     IPython.Notebook = Notebook;
 
     return IPython;
 
 }(IPython));
 

IPython/nbformat/v2/nbbase.py

@@ -1,122 +1,136 b''
 """The basic dict based notebook format."""
 
 import pprint
 import uuid
 
 from IPython.utils.ipstruct import Struct
 
 
 class NotebookNode(Struct):
     pass
 
 
 def from_dict(d):
     if isinstance(d, dict):
         newd = NotebookNode()
         for k,v in d.items():
             newd[k] = from_dict(v)
         return newd
     elif isinstance(d, (tuple, list)):
         return [from_dict(i) for i in d]
     else:
         return d
 
 
 def new_output(output_type=None, output_text=None, output_png=None,
     output_html=None, output_svg=None, output_latex=None, output_json=None, 
-    output_javascript=None, output_jpeg=None, prompt_number=None):
+    output_javascript=None, output_jpeg=None, prompt_number=None,
+    etype=None, evalue=None, traceback=None):
     """Create a new code cell with input and output"""
     output = NotebookNode()
     if output_type is not None:
         output.output_type = unicode(output_type)
-    if output_text is not None:
-        output.text = unicode(output_text)
-    if output_png is not None:
-        output.png = bytes(output_png)
-    if output_jpeg is not None:
-        output.jpeg = bytes(output_jpeg)
-    if output_html is not None:
-        output.html = unicode(output_html)
-    if output_svg is not None:
-        output.svg = unicode(output_svg)
-    if output_latex is not None:
-        output.latex = unicode(output_latex)
-    if output_json is not None:
-        output.json = unicode(output_json)
-    if output_javascript is not None:
-        output.javascript = unicode(output_javascript)
-    if prompt_number is not None:
-        output.prompt_number = int(prompt_number)
+
+    if output_type != 'pyerr':
+        if output_text is not None:
+            output.text = unicode(output_text)
+        if output_png is not None:
+            output.png = bytes(output_png)
+        if output_jpeg is not None:
+            output.jpeg = bytes(output_jpeg)
+        if output_html is not None:
+            output.html = unicode(output_html)
+        if output_svg is not None:
+            output.svg = unicode(output_svg)
+        if output_latex is not None:
+            output.latex = unicode(output_latex)
+        if output_json is not None:
+            output.json = unicode(output_json)
+        if output_javascript is not None:
+            output.javascript = unicode(output_javascript)
+
+    if output_type == u'pyout':
+        if prompt_number is not None:
+            output.prompt_number = int(prompt_number)
+
+    if output_type == u'pyerr':
+        if etype is not None:
+            output.etype = unicode(etype)
+        if evalue is not None:
+            output.evalue = unicode(evalue)
+        if traceback is not None:
+            output.traceback = [unicode(frame) for frame in list(traceback)]
+
     return output
 
 
 def new_code_cell(input=None, prompt_number=None, outputs=None,
     language=u'python', collapsed=False):
     """Create a new code cell with input and output"""
     cell = NotebookNode()
     cell.cell_type = u'code'
     if language is not None:
         cell.language = unicode(language)
     if input is not None:
         cell.input = unicode(input)
     if prompt_number is not None:
         cell.prompt_number = int(prompt_number)
     if outputs is None:
         cell.outputs = []
     else:
         cell.outputs = outputs
     if collapsed is not None:
         cell.collapsed = bool(collapsed)
 
     return cell
 
 def new_text_cell(cell_type, source=None, rendered=None):
     """Create a new text cell."""
     cell = NotebookNode()
     if source is not None:
         cell.source = unicode(source)
     if rendered is not None:
         cell.rendered = unicode(rendered)
     cell.cell_type = cell_type
     return cell
 
 
 def new_worksheet(name=None, cells=None):
     """Create a worksheet by name with with a list of cells."""
     ws = NotebookNode()
     if name is not None:
         ws.name = unicode(name)
     if cells is None:
         ws.cells = []
     else:
         ws.cells = list(cells)
     return ws
 
 
 def new_notebook(name=None, id=None, worksheets=None, author=None, email=None,
     created=None, saved=None, license=None):
     """Create a notebook by name, id and a list of worksheets."""
     nb = NotebookNode()
     nb.nbformat = 2
     if name is not None:
         nb.name = unicode(name)
     if id is None:
         nb.id = unicode(uuid.uuid4())
     else:
         nb.id = unicode(id)
     if worksheets is None:
         nb.worksheets = []
     else:
         nb.worksheets = list(worksheets)
     if author is not None:
         nb.author = unicode(author)
     if email is not None:
         nb.email = unicode(email)
     if created is not None:
         nb.created = unicode(created)
     if saved is not None:
         nb.saved = unicode(saved)
     if license is not None:
         nb.license = unicode(license)
     return nb
 

IPython/nbformat/v2/nbxml.py

@@ -1,210 +1,228 b''
 """Read and write notebook files as XML."""
 
 from base64 import encodestring, decodestring
 from xml.etree import ElementTree as ET
 
 from .rwbase import NotebookReader, NotebookWriter
 from .nbbase import (
     new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output
 )
 
 def indent(elem, level=0):
     i = "\n" + level*"  "
     if len(elem):
         if not elem.text or not elem.text.strip():
             elem.text = i + "  "
         if not elem.tail or not elem.tail.strip():
             elem.tail = i
         for elem in elem:
             indent(elem, level+1)
         if not elem.tail or not elem.tail.strip():
             elem.tail = i
     else:
         if level and (not elem.tail or not elem.tail.strip()):
             elem.tail = i
 
 
 def _get_text(e, tag):
     sub_e = e.find(tag)
     if sub_e is None:
         return None
     else:
         return sub_e.text
 
 
 def _set_text(nbnode, attr, parent, tag):
     if attr in nbnode:
         e = ET.SubElement(parent, tag)
         e.text = nbnode[attr]
 
 
 def _get_int(e, tag):
     sub_e = e.find(tag)
     if sub_e is None:
         return None
     else:
         return int(sub_e.text)
 
 
 def _set_int(nbnode, attr, parent, tag):
     if attr in nbnode:
         e = ET.SubElement(parent, tag)
         e.text = unicode(nbnode[attr])
 
 
 def _get_bool(e, tag):
     sub_e = e.find(tag)
     if sub_e is None:
         return None
     else:
         return bool(int(sub_e.text))
 
 
 def _set_bool(nbnode, attr, parent, tag):
     if attr in nbnode:
         e = ET.SubElement(parent, tag)
         if nbnode[attr]:
             e.text = u'1'
         else:
             e.text = u'0'
 
 
 def _get_binary(e, tag):
     sub_e = e.find(tag)
     if sub_e is None:
         return None
     else:
         return decodestring(sub_e.text)
 
 
 def _set_binary(nbnode, attr, parent, tag):
     if attr in nbnode:
         e = ET.SubElement(parent, tag)
         e.text = encodestring(nbnode[attr])
 
 
 class XMLReader(NotebookReader):
 
     def reads(self, s, **kwargs):
         root = ET.fromstring(s)
         return self.to_notebook(root, **kwargs)
 
     def to_notebook(self, root, **kwargs):
-        nbname = _get_text(root,'name')
-        nbid = _get_text(root,'id')
-        nbauthor = _get_text(root,'author')
-        nbemail = _get_text(root,'email')
-        nblicense = _get_text(root,'license')
-        nbcreated = _get_text(root,'created')
-        nbsaved = _get_text(root,'saved')
+        nbname = _get_text(root,u'name')
+        nbid = _get_text(root,u'id')
+        nbauthor = _get_text(root,u'author')
+        nbemail = _get_text(root,u'email')
+        nblicense = _get_text(root,u'license')
+        nbcreated = _get_text(root,u'created')
+        nbsaved = _get_text(root,u'saved')
         
         worksheets = []
-        for ws_e in root.find('worksheets').getiterator('worksheet'):
-            wsname = _get_text(ws_e,'name')
+        for ws_e in root.find(u'worksheets').getiterator(u'worksheet'):
+            wsname = _get_text(ws_e,u'name')
             cells = []
-            for cell_e in ws_e.find('cells').getiterator():
-                if cell_e.tag == 'codecell':
-                    input = _get_text(cell_e,'input')
-                    prompt_number = _get_int(cell_e,'prompt_number')
-                    collapsed = _get_bool(cell_e,'collapsed')
-                    language = _get_text(cell_e,'language')
+            for cell_e in ws_e.find(u'cells').getiterator():
+                if cell_e.tag == u'codecell':
+                    input = _get_text(cell_e,u'input')
+                    prompt_number = _get_int(cell_e,u'prompt_number')
+                    collapsed = _get_bool(cell_e,u'collapsed')
+                    language = _get_text(cell_e,u'language')
                     outputs = []
-                    for output_e in cell_e.find('outputs').getiterator('output'):
-                        out_prompt_number = _get_int(output_e,'prompt_number')
-                        output_type = _get_text(output_e,'output_type')
-                        output_text = _get_text(output_e,'text')
-                        output_png = _get_binary(output_e,'png')
-                        output_jpeg = _get_binary(output_e,'jpeg')
-                        output_svg = _get_text(output_e,'svg')
-                        output_html = _get_text(output_e,'html')
-                        output_latex = _get_text(output_e,'latex')
-                        output_json = _get_text(output_e,'json')
-                        output_javascript = _get_text(output_e,'javascript')
+                    for output_e in cell_e.find(u'outputs').getiterator(u'output'):
+                        output_type = _get_text(output_e,u'output_type')
+                        output_text = _get_text(output_e,u'text')
+                        output_png = _get_binary(output_e,u'png')
+                        output_jpeg = _get_binary(output_e,u'jpeg')
+                        output_svg = _get_text(output_e,u'svg')
+                        output_html = _get_text(output_e,u'html')
+                        output_latex = _get_text(output_e,u'latex')
+                        output_json = _get_text(output_e,u'json')
+                        output_javascript = _get_text(output_e,u'javascript')
+
+                        out_prompt_number = _get_int(output_e,u'prompt_number')
+                        etype = _get_text(output_e,u'etype')
+                        evalue = _get_text(output_e,u'evalue')
+                        traceback = []
+                        traceback_e = output_e.find(u'traceback')
+                        if traceback_e is not None:
+                            for frame_e in traceback_e.getiterator(u'frame'):
+                                traceback.append(frame_e.text)
+                        if len(traceback) == 0:
+                            traceback = None
                         output = new_output(output_type=output_type,output_png=output_png,
                             output_text=output_text, output_svg=output_svg,
                             output_html=output_html, output_latex=output_latex,
                             output_json=output_json, output_javascript=output_javascript,
-                            output_jpeg=output_jpeg, prompt_number=out_prompt_number
+                            output_jpeg=output_jpeg, prompt_number=out_prompt_number,
+                            etype=etype, evalue=evalue, traceback=traceback
                         )
                         outputs.append(output)
                     cc = new_code_cell(input=input,prompt_number=prompt_number,
                                        language=language,outputs=outputs,collapsed=collapsed)
                     cells.append(cc)
-                if cell_e.tag == 'htmlcell':
-                    source = _get_text(cell_e,'source')
-                    rendered = _get_text(cell_e,'rendered')
+                if cell_e.tag == u'htmlcell':
+                    source = _get_text(cell_e,u'source')
+                    rendered = _get_text(cell_e,u'rendered')
                     cells.append(new_text_cell(u'html', source=source, rendered=rendered))
-                if cell_e.tag == 'markdowncell':
-                    source = _get_text(cell_e,'source')
-                    rendered = _get_text(cell_e,'rendered')
+                if cell_e.tag == u'markdowncell':
+                    source = _get_text(cell_e,u'source')
+                    rendered = _get_text(cell_e,u'rendered')
                     cells.append(new_text_cell(u'markdown', source=source, rendered=rendered))
             ws = new_worksheet(name=wsname,cells=cells)
             worksheets.append(ws)
 
         nb = new_notebook(name=nbname,id=nbid,worksheets=worksheets,author=nbauthor,
             email=nbemail,license=nblicense,saved=nbsaved,created=nbcreated)
         return nb
 
 
 class XMLWriter(NotebookWriter):
 
     def writes(self, nb, **kwargs):
-        nb_e = ET.Element('notebook')
-        _set_text(nb,'name',nb_e,'name')
-        _set_text(nb,'id',nb_e,'id')
-        _set_text(nb,'author',nb_e,'author')
-        _set_text(nb,'email',nb_e,'email')
-        _set_text(nb,'license',nb_e,'license')
-        _set_text(nb,'created',nb_e,'created')
-        _set_text(nb,'saved',nb_e,'saved')
-        _set_int(nb,'nbformat',nb_e,'nbformat')
-        wss_e = ET.SubElement(nb_e,'worksheets')
+        nb_e = ET.Element(u'notebook')
+        _set_text(nb,u'name',nb_e,u'name')
+        _set_text(nb,u'id',nb_e,u'id')
+        _set_text(nb,u'author',nb_e,u'author')
+        _set_text(nb,u'email',nb_e,u'email')
+        _set_text(nb,u'license',nb_e,u'license')
+        _set_text(nb,u'created',nb_e,u'created')
+        _set_text(nb,u'saved',nb_e,u'saved')
+        _set_int(nb,u'nbformat',nb_e,u'nbformat')
+        wss_e = ET.SubElement(nb_e,u'worksheets')
         for ws in nb.worksheets:
-            ws_e = ET.SubElement(wss_e, 'worksheet')
-            _set_text(ws,'name',ws_e,'name')
-            cells_e = ET.SubElement(ws_e,'cells')
+            ws_e = ET.SubElement(wss_e, u'worksheet')
+            _set_text(ws,u'name',ws_e,u'name')
+            cells_e = ET.SubElement(ws_e,u'cells')
             for cell in ws.cells:
                 cell_type = cell.cell_type
-                if cell_type == 'code':
-                    cell_e = ET.SubElement(cells_e, 'codecell')
-                    _set_text(cell,'input',cell_e,'input')
-                    _set_text(cell,'language',cell_e,'language')
-                    _set_int(cell,'prompt_number',cell_e,'prompt_number')
-                    _set_bool(cell,'collapsed',cell_e,'collapsed')
-                    outputs_e = ET.SubElement(cell_e, 'outputs')
+                if cell_type == u'code':
+                    cell_e = ET.SubElement(cells_e, u'codecell')
+                    _set_text(cell,u'input',cell_e,u'input')
+                    _set_text(cell,u'language',cell_e,u'language')
+                    _set_int(cell,u'prompt_number',cell_e,u'prompt_number')
+                    _set_bool(cell,u'collapsed',cell_e,u'collapsed')
+                    outputs_e = ET.SubElement(cell_e, u'outputs')
                     for output in cell.outputs:
-                        output_e = ET.SubElement(outputs_e, 'output')
-                        _set_int(output,'prompt_number',output_e,'prompt_number')
-                        _set_text(output,'output_type',output_e,'output_type')
-                        _set_text(output,'text',output_e,'text')
-                        _set_binary(output,'png',output_e,'png')
-                        _set_binary(output,'jpeg',output_e,'jpeg')
-                        _set_text(output,'html',output_e,'html')
-                        _set_text(output,'svg',output_e,'svg')
-                        _set_text(output,'latex',output_e,'latex')
-                        _set_text(output,'json',output_e,'json')
-                        _set_text(output,'javascript',output_e,'javascript')
-                elif cell_type == 'html':
-                    cell_e = ET.SubElement(cells_e, 'htmlcell')
-                    _set_text(cell,'source',cell_e,'source')
-                    _set_text(cell,'rendered',cell_e,'rendered')
-                elif cell_type == 'markdown':
-                    cell_e = ET.SubElement(cells_e, 'markdowncell')
-                    _set_text(cell,'source',cell_e,'source')
-                    _set_text(cell,'rendered',cell_e,'rendered')
+                        output_e = ET.SubElement(outputs_e, u'output')
+                        _set_text(output,u'output_type',output_e,u'output_type')
+                        _set_text(output,u'text',output_e,u'text')
+                        _set_binary(output,u'png',output_e,u'png')
+                        _set_binary(output,u'jpeg',output_e,u'jpeg')
+                        _set_text(output,u'html',output_e,u'html')
+                        _set_text(output,u'svg',output_e,u'svg')
+                        _set_text(output,u'latex',output_e,u'latex')
+                        _set_text(output,u'json',output_e,u'json')
+                        _set_text(output,u'javascript',output_e,u'javascript')
+                        _set_int(output,u'prompt_number',output_e,u'prompt_number')
+                        _set_text(output,u'etype',output_e,u'etype')
+                        _set_text(output,u'evalue',output_e,u'evalue')
+                        if u'traceback' in output:
+                            tb_e = ET.SubElement(output_e, u'traceback')
+                            for frame in output.traceback:
+                                frame_e = ET.SubElement(tb_e, u'frame')
+                                frame_e.text = frame
+                elif cell_type == u'html':
+                    cell_e = ET.SubElement(cells_e, u'htmlcell')
+                    _set_text(cell,u'source',cell_e,u'source')
+                    _set_text(cell,u'rendered',cell_e,u'rendered')
+                elif cell_type == u'markdown':
+                    cell_e = ET.SubElement(cells_e, u'markdowncell')
+                    _set_text(cell,u'source',cell_e,u'source')
+                    _set_text(cell,u'rendered',cell_e,u'rendered')
 
         indent(nb_e)
         txt = ET.tostring(nb_e, encoding="utf-8")
         txt = '<?xml version="1.0" encoding="utf-8"?>\n' + txt
         return txt
         
                     
 _reader = XMLReader()
 _writer = XMLWriter()
 
 reads = _reader.reads
 read = _reader.read
 to_notebook = _reader.to_notebook
 write = _writer.write
 writes = _writer.writes
 

IPython/nbformat/v2/tests/nbexamples.py

@@ -1,98 +1,102 b''
 from ..nbbase import (
     NotebookNode,
     new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output
 )
 
 
 
 ws = new_worksheet(name='worksheet1')
 
 ws.cells.append(new_text_cell(
     u'html',
     source='Some NumPy Examples',
     rendered='Some NumPy Examples'
 ))
 
 
 ws.cells.append(new_code_cell(
     input='import numpy',
     prompt_number=1,
     collapsed=False
 ))
 
 ws.cells.append(new_text_cell(
     u'markdown',
     source='A random array',
     rendered='A random array'
 ))
 
 ws.cells.append(new_code_cell(
     input='a = numpy.random.rand(100)',
     prompt_number=2,
     collapsed=True
 ))
 
 ws.cells.append(new_code_cell(
     input='print a',
     prompt_number=3,
     collapsed=False,
     outputs=[new_output(
         output_type=u'pyout',
         output_text=u'<array a>',
         output_html=u'The HTML rep',
         output_latex=u'$a$',
         output_png=b'data',
         output_jpeg=b'data',
         output_svg=u'<svg>',
         output_json=u'json data',
         output_javascript=u'var i=0;',
         prompt_number=3
     ),new_output(
         output_type=u'display_data',
         output_text=u'<array a>',
         output_html=u'The HTML rep',
         output_latex=u'$a$',
         output_png=b'data',
         output_jpeg=b'data',
         output_svg=u'<svg>',
         output_json=u'json data',
-        output_javascript=u'var i=0;',
-        prompt_number=4
+        output_javascript=u'var i=0;'
+    ),new_output(
+        output_type=u'pyerr',
+        etype=u'NameError',
+        evalue=u'NameError was here',
+        traceback=[u'frame 0', u'frame 1', u'frame 2']
     )]
 ))
 
 nb0 = new_notebook(
     name='nb0',
     worksheets=[ws, new_worksheet(name='worksheet2')],
     author='Bart Simpson',
-    email='[e-mail]',
+    email='[e-mail]',
     saved='ISO8601_goes_here',
     created='ISO8601_goes_here',
     license='BSD'
 )
 
 nb0_py = """# <nbformat>2</nbformat>
 
 # <htmlcell>
 
 # Some NumPy Examples
 
 # <codecell>
 
 import numpy
 
 # <markdowncell>
 
 # A random array
 
 # <codecell>
 
 a = numpy.random.rand(100)
 
 # <codecell>
 
 print a
 
 """
 
 

IPython/nbformat/v2/tests/test_nbbase.py

@@ -1,82 +1,90 b''
 from unittest import TestCase
 
 from ..nbbase import (
     NotebookNode,
     new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output
 )
 
 class TestCell(TestCase):
 
     def test_empty_code_cell(self):
         cc = new_code_cell()
         self.assertEquals(cc.cell_type,'code')
         self.assertEquals('input' not in cc, True)
         self.assertEquals('prompt_number' not in cc, True)
         self.assertEquals(cc.outputs, [])
         self.assertEquals(cc.collapsed, False)
 
     def test_code_cell(self):
         cc = new_code_cell(input='a=10', prompt_number=0, collapsed=True)
         cc.outputs = [new_output(output_type='pyout',
             output_svg='foo',output_text='10',prompt_number=0)]
         self.assertEquals(cc.input, u'a=10')
         self.assertEquals(cc.prompt_number, 0)
         self.assertEquals(cc.language, u'python')
         self.assertEquals(cc.outputs[0].svg, u'foo')
         self.assertEquals(cc.outputs[0].text, u'10')
         self.assertEquals(cc.outputs[0].prompt_number, 0)
         self.assertEquals(cc.collapsed, True)
 
+    def test_pyerr(self):
+        o = new_output(output_type=u'pyerr', etype=u'NameError',
+            evalue=u'Name not found', traceback=[u'frame 0', u'frame 1', u'frame 2']
+        )
+        self.assertEquals(o.output_type, u'pyerr')
+        self.assertEquals(o.etype, u'NameError')
+        self.assertEquals(o.evalue, u'Name not found')
+        self.assertEquals(o.traceback, [u'frame 0', u'frame 1', u'frame 2'])
 
     def test_empty_html_cell(self):
         tc = new_text_cell(u'html')
         self.assertEquals(tc.cell_type, u'html')
         self.assertEquals('source' not in tc, True)
         self.assertEquals('rendered' not in tc, True)
 
     def test_html_cell(self):
         tc = new_text_cell(u'html', 'hi', 'hi')
         self.assertEquals(tc.source, u'hi')
         self.assertEquals(tc.rendered, u'hi')
 
     def test_empty_markdown_cell(self):
         tc = new_text_cell(u'markdown')
         self.assertEquals(tc.cell_type, u'markdown')
         self.assertEquals('source' not in tc, True)
         self.assertEquals('rendered' not in tc, True)
 
     def test_markdown_cell(self):
         tc = new_text_cell(u'markdown', 'hi', 'hi')
         self.assertEquals(tc.source, u'hi')
         self.assertEquals(tc.rendered, u'hi')
 
 
 class TestWorksheet(TestCase):
 
     def test_empty_worksheet(self):
         ws = new_worksheet()
         self.assertEquals(ws.cells,[])
         self.assertEquals('name' not in ws, True)
 
     def test_worksheet(self):
         cells = [new_code_cell(), new_text_cell(u'html')]
         ws = new_worksheet(cells=cells,name='foo')
         self.assertEquals(ws.cells,cells)
         self.assertEquals(ws.name,u'foo')
 
 class TestNotebook(TestCase):
 
     def test_empty_notebook(self):
         nb = new_notebook()
         self.assertEquals('id' in nb, True)
         self.assertEquals(nb.worksheets, [])
         self.assertEquals('name' not in nb, True)
         self.assertEquals(nb.nbformat,2)
 
     def test_notebook(self):
         worksheets = [new_worksheet(),new_worksheet()]
         nb = new_notebook(name='foo',worksheets=worksheets)
         self.assertEquals(nb.name,u'foo')
         self.assertEquals(nb.worksheets,worksheets)
         self.assertEquals(nb.nbformat,2)