Markdown cells are now saved and restored in notebooks.

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

@@ -1,718 +1,721 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();
     };
 
 
     // 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(payload);
     };
 
 
     Notebook.prototype.handle_payload = function (payload) {
         var l = payload.length;
         if (l > 0) {
             IPython.pager.clear();
             IPython.pager.expand();
         };
         for (var i=0; i<l; i++) {
             IPython.pager.append_text(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';
         } 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;
         };
         cell.append_output(json);
     };
 
 
     Notebook.prototype.convert_mime_types = function (json, data) {
         if (data['text/plain'] !== undefined) {
             json.text = 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['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) {
         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/frontend/html/notebook/static/js/textcell.js

@@ -1,249 +1,249 b''
 
 //============================================================================
 // TextCell
 //============================================================================
 
 var IPython = (function (IPython) {
 
     // TextCell base class
 
     var TextCell = function (notebook) {
         this.code_mirror_mode = this.code_mirror_mode || 'htmlmixed';
         this.placeholder = this.placeholder || '';
         IPython.Cell.apply(this, arguments);
         this.rendered = false;
         this.cell_type = this.cell_type || 'text';
     };
 
 
     TextCell.prototype = new IPython.Cell();
 
 
     TextCell.prototype.create_element = function () {
         var cell = $("<div>").addClass('cell text_cell border-box-sizing');
         var input_area = $('<div/>').addClass('text_cell_input');
         this.code_mirror = CodeMirror(input_area.get(0), {
             indentUnit : 4,
             enterMode : 'flat',
             tabMode: 'shift',
             mode: this.code_mirror_mode,
             theme: 'default',
             value: this.placeholder
         });
         // The tabindex=-1 makes this div focusable.
         var render_area = $('<div/>').addClass('text_cell_render').
             addClass('rendered_html').attr('tabindex','-1');
         cell.append(input_area).append(render_area);
         this.element = cell;
     };
 
 
     TextCell.prototype.bind_events = function () {
         IPython.Cell.prototype.bind_events.apply(this);
         var that = this;
         this.element.keydown(function (event) {
             if (event.which === 13) {
                 if (that.rendered) {
                     that.edit();
                     event.preventDefault();
                 };
             };
         });
     };
 
 
     TextCell.prototype.select = function () {
         IPython.Cell.prototype.select.apply(this);
         var output = this.element.find("div.text_cell_render");
         output.trigger('focus');
     };
 
 
     TextCell.prototype.edit = function () {
         if (this.rendered === true) {
             var text_cell = this.element;
             var output = text_cell.find("div.text_cell_render");  
             output.hide();
             text_cell.find('div.text_cell_input').show();
             this.code_mirror.focus();
             this.code_mirror.refresh();
             this.rendered = false;
         };
     };
 
 
     // Subclasses must define render.
     TextCell.prototype.render = function () {};
 
 
     TextCell.prototype.config_mathjax = function () {
         var text_cell = this.element;
         var that = this;
         text_cell.click(function () {
             that.edit();
         }).focusout(function () {
             that.render();
         });
         
         text_cell.trigger("focusout");
     };
 
 
     TextCell.prototype.get_source = function() {
         return this.code_mirror.getValue();
     };
 
 
     TextCell.prototype.set_source = function(text) {
         this.code_mirror.setValue(text);
         this.code_mirror.refresh();
     };
 
 
     TextCell.prototype.get_rendered = function(text) {
         return this.element.find('div.text_cell_render').html();
     };
 
 
     TextCell.prototype.set_rendered = function(text) {
         this.element.find('div.text_cell_render').html(text);
     };
 
 
     TextCell.prototype.at_top = function () {
         if (this.rendered) {
             return true;
         } else {
             return false;
         }
     };
 
 
     TextCell.prototype.at_bottom = function () {
         if (this.rendered) {
             return true;
         } else {
             return false;
         }
     };
 
 
     TextCell.prototype.fromJSON = function (data) {
         if (data.cell_type === this.cell_type) {
             if (data.source !== undefined) {
                 this.set_source(data.source);
-                this.set_rendered(data.source);
+                this.set_rendered(data.rendered);
             };
         };
     }
 
 
     TextCell.prototype.toJSON = function () {
         var data = {}
         data.cell_type = this.cell_type;
         data.source = this.get_source();
         data.rendered = this.get_rendered();
         return data;
     };
 
 
     // HTMLCell
 
     var HTMLCell = function (notebook) {
         this.placeholder = "Type <strong>HTML</strong> and LaTeX: $\\alpha^2$";
         IPython.TextCell.apply(this, arguments);
         this.cell_type = 'html';
     };
 
 
     HTMLCell.prototype = new TextCell();
 
 
     HTMLCell.prototype.render = function () {
         if (this.rendered === false) {
             var text = this.get_source();
             if (text === "") {text = this.placeholder;};
             this.set_rendered(text);
             MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
             this.element.find('div.text_cell_input').hide();
             this.element.find("div.text_cell_render").show();
             this.rendered = true;
         };
     };
 
 
     // MarkdownCell
 
     var MarkdownCell = function (notebook) {
         this.placeholder = "Type *Markdown* and LaTeX: $\\alpha^2$";
         IPython.TextCell.apply(this, arguments);
         this.cell_type = 'markdown';
     };
 
 
     MarkdownCell.prototype = new TextCell();
 
 
     MarkdownCell.prototype.render = function () {
         if (this.rendered === false) {
             var text = this.get_source();
             if (text === "") {text = this.placeholder;};
             var html = IPython.markdown_converter.makeHtml(text);
             this.set_rendered(html);
             MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
             this.element.find('div.text_cell_input').hide();
             this.element.find("div.text_cell_render").show();
             this.rendered = true;
         };
     };
 
 
     // RSTCell
 
     var RSTCell = function (notebook) {
         this.placeholder = "Type *ReStructured Text* and LaTeX: $\\alpha^2$";
         IPython.TextCell.apply(this, arguments);
         this.cell_type = 'rst';
     };
 
 
     RSTCell.prototype = new TextCell();
 
 
     RSTCell.prototype.render = function () {
         if (this.rendered === false) {  
             var text = this.get_source();
             if (text === "") {text = this.placeholder;};
             var settings = {
                 processData : false,
                 cache : false,
                 type : "POST",
                 data : text,
                 headers : {'Content-Type': 'application/x-rst'},
                 success : $.proxy(this.handle_render,this)
             };
             $.ajax("/rstservice/render", settings);
             this.element.find('div.text_cell_input').hide();
             this.element.find("div.text_cell_render").show();
             this.set_rendered("Rendering...");
         };
     };
 
 
     RSTCell.prototype.handle_render = function (data, status, xhr) {
         this.set_rendered(data);
         MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
         this.rendered = true;
     };
 
 
     IPython.TextCell = TextCell;
     IPython.HTMLCell = HTMLCell;
     IPython.MarkdownCell = MarkdownCell;
     IPython.RSTCell = RSTCell;
 
 
     return IPython;
 
 }(IPython));
 

IPython/nbformat/current.py

@@ -1,195 +1,195 b''
 import json
 from xml.etree import ElementTree as ET
 import re
 
 from IPython.nbformat import v2
 from IPython.nbformat import v1
 
 from IPython.nbformat.v2 import (
     NotebookNode,
-    new_code_cell, new_html_cell, new_notebook, new_output, new_worksheet
+    new_code_cell, new_text_cell, new_notebook, new_output, new_worksheet
 )
 
 
 current_nbformat = 2
 
 
 class NBFormatError(Exception):
     pass
 
 
 def parse_json(s, **kwargs):
     """Parse a string into a (nbformat, dict) tuple."""
     d = json.loads(s, **kwargs)
     nbformat = d.get('nbformat',1)
     return nbformat, d
 
 
 def parse_xml(s, **kwargs):
     """Parse a string into a (nbformat, etree) tuple."""
     root = ET.fromstring(s)
     nbformat_e = root.find('nbformat')
     if nbformat_e is not None:
         nbformat = int(nbformat_e.text)
     else:
         raise NBFormatError('No nbformat version found')
     return nbformat, root
 
 
 def parse_py(s, **kwargs):
     """Parse a string into a (nbformat, string) tuple."""
     pattern = r'# <nbformat>(?P<nbformat>\d+)</nbformat>'
     m = re.search(pattern,s)
     if m is not None:
         nbformat = int(m.group('nbformat'))
     else:
         nbformat = 2
     return nbformat, s
 
 
 def reads_json(s, **kwargs):
     """Read a JSON notebook from a string and return the NotebookNode object."""
     nbformat, d = parse_json(s, **kwargs)
     if nbformat == 1:
         nb = v1.to_notebook_json(d, **kwargs)
         nb = v2.convert_to_this_nbformat(nb, orig_version=1)
     elif nbformat == 2:
         nb = v2.to_notebook_json(d, **kwargs)
     else:
         raise NBFormatError('Unsupported JSON nbformat version: %i' % nbformat)
     return nb
 
 
 def writes_json(nb, **kwargs):
     return v2.writes_json(nb, **kwargs)
 
 
 def reads_xml(s, **kwargs):
     """Read an XML notebook from a string and return the NotebookNode object."""
     nbformat, root = parse_xml(s, **kwargs)
     if nbformat == 2:
         nb = v2.to_notebook_xml(root, **kwargs)
     else:
         raise NBFormatError('Unsupported XML nbformat version: %i' % nbformat)
     return nb
 
 
 def writes_xml(nb, **kwargs):
     return v2.writes_xml(nb, **kwargs)
 
 
 def reads_py(s, **kwargs):
     """Read a .py notebook from a string and return the NotebookNode object."""
     nbformat, s = parse_py(s, **kwargs)
     if nbformat == 2:
         nb = v2.to_notebook_py(s, **kwargs)
     else:
         raise NBFormatError('Unsupported PY nbformat version: %i' % nbformat)
     return nb
 
 
 def writes_py(nb, **kwargs):
     return v2.writes_py(nb, **kwargs)
 
 
 # High level API
 
 
 def reads(s, format, **kwargs):
     """Read a notebook from a string and return the NotebookNode object.
 
     This function properly handles notebooks of any version. The notebook
     returned will always be in the current version's format.
 
     Parameters
     ----------
     s : str
         The raw string to read the notebook from.
     format : ('xml','json','py')
         The format that the string is in.
 
     Returns
     -------
     nb : NotebookNode
         The notebook that was read.
     """
     if format == 'xml':
         return reads_xml(s, **kwargs)
     elif format == 'json':
         return reads_json(s, **kwargs)
     elif format == 'py':
         return reads_py(s, **kwargs)
     else:
         raise NBFormatError('Unsupported format: %s' % format)
 
 
 def writes(nb, format, **kwargs):
     """Write a notebook to a string in a given format in the current nbformat version.
 
     This function always writes the notebook in the current nbformat version.
 
     Parameters
     ----------
     nb : NotebookNode
         The notebook to write.
     format : ('xml','json','py')
         The format to write the notebook in.
 
     Returns
     -------
     s : str
         The notebook string.
     """
     if format == 'xml':
         return writes_xml(nb, **kwargs)
     elif format == 'json':
         return writes_json(nb, **kwargs)
     elif format == 'py':
         return writes_py(nb, **kwargs)
     else:
         raise NBFormatError('Unsupported format: %s' % format)
 
 
 def read(fp, format, **kwargs):
     """Read a notebook from a file and return the NotebookNode object.
 
     This function properly handles notebooks of any version. The notebook
     returned will always be in the current version's format.
 
     Parameters
     ----------
     fp : file
         Any file-like object with a read method.
     format : ('xml','json','py')
         The format that the string is in.
 
     Returns
     -------
     nb : NotebookNode
         The notebook that was read.
     """
     return reads(fp.read(), format, **kwargs)
 
 
 def write(nb, fp, format, **kwargs):
     """Write a notebook to a file in a given format in the current nbformat version.
 
     This function always writes the notebook in the current nbformat version.
 
     Parameters
     ----------
     nb : NotebookNode
         The notebook to write.
     fp : file
         Any file-like object with a write method.
     format : ('xml','json','py')
         The format to write the notebook in.
 
     Returns
     -------
     s : str
         The notebook string.
     """
     return fp.write(writes(nb, format, **kwargs))
 
 

IPython/nbformat/v2/__init__.py

@@ -1,21 +1,21 b''
 
 from .nbbase import (
     NotebookNode,
-    new_code_cell, new_html_cell, new_notebook, new_output, new_worksheet
+    new_code_cell, new_text_cell, new_notebook, new_output, new_worksheet
 )
 
 from .nbjson import reads as reads_json, writes as writes_json
 from .nbjson import reads as read_json, writes as write_json
 from .nbjson import to_notebook as to_notebook_json
 
 from .nbxml import reads as reads_xml, writes as writes_xml
 from .nbxml import reads as read_xml, writes as write_xml
 from .nbxml import to_notebook as to_notebook_xml
 
 from .nbpy import reads as reads_py, writes as writes_py
 from .nbpy import reads as read_py, writes as write_py
 from .nbpy import to_notebook as to_notebook_py
 
 from .convert import convert_to_this_nbformat
 
 

IPython/nbformat/v2/convert.py

@@ -1,20 +1,20 b''
 from .nbbase import (
-    new_code_cell, new_html_cell, new_worksheet, new_notebook, new_output
+    new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output
 )
 
 def convert_to_this_nbformat(nb, orig_version=1):
     if orig_version == 1:
         newnb = new_notebook()
         ws = new_worksheet()
         for cell in nb.cells:
-            if cell.cell_type == 'code':
+            if cell.cell_type == u'code':
                 newcell = new_code_cell(input=cell.get('code'),prompt_number=cell.get('prompt_number'))
-            elif cell.cell_type == 'text':
-                newcell = new_html_cell(source=cell.get('text'))
+            elif cell.cell_type == u'text':
+                newcell = new_text_cell(u'markdown',source=cell.get('text'))
             ws.cells.append(newcell)
         newnb.worksheets.append(ws)
         return newnb
     else:
         raise ValueError('Cannot convert a notebook from v%s to v2' % orig_version)
 
 

IPython/nbformat/v2/nbbase.py

@@ -1,104 +1,106 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, prompt_number=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_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)
     return output
 
 
 def new_code_cell(input=None, prompt_number=None, outputs=None, language=u'python'):
     """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
 
     return cell
 
-def new_html_cell(source=None):
+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)
-    cell.cell_type = u'html'
+    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):
     """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)
     return nb
 

IPython/nbformat/v2/nbxml.py

@@ -1,168 +1,178 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_html_cell, new_worksheet, new_notebook, new_output
+    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_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')
         
         worksheets = []
         for ws_e in root.find('worksheets').getiterator('worksheet'):
             wsname = _get_text(ws_e,'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')
                     language = _get_text(cell_e,'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_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')
                         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,
                             prompt_number=out_prompt_number
                         )
                         outputs.append(output)
                     cc = new_code_cell(input=input,prompt_number=prompt_number,
                                        language=language,outputs=outputs)
                     cells.append(cc)
                 if cell_e.tag == 'htmlcell':
                     source = _get_text(cell_e,'source')
-                    cells.append(new_html_cell(source=source))
+                    rendered = _get_text(cell_e,'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')
+                    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)
         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_int(nb,'nbformat',nb_e,'nbformat')
         wss_e = ET.SubElement(nb_e,'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')
             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')
                     outputs_e = ET.SubElement(cell_e, '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_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')
 
         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,75 +1,83 b''
 from ..nbbase import (
     NotebookNode,
-    new_code_cell, new_html_cell, new_worksheet, new_notebook, new_output
+    new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output
 )
 
 
 
 ws = new_worksheet(name='worksheet1')
 
-ws.cells.append(new_html_cell(
-    source='Some NumPy Examples'
+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
 ))
 
+ws.cells.append(new_text_cell(
+    u'markdown',
+    source='Some NumPy Examples',
+    rendered='Some NumPy Examples'
+))
+
 ws.cells.append(new_code_cell(
     input='a = numpy.random.rand(100)',
     prompt_number=2
 ))
 
 ws.cells.append(new_code_cell(
     input='print a',
     prompt_number=3,
     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_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_svg=u'<svg>',
         output_json=u'json data',
         output_javascript=u'var i=0;',
         prompt_number=4
     )]
 ))
 
 nb0 = new_notebook(
     name='nb0',
     worksheets=[ws, new_worksheet(name='worksheet2')]
 )
 
 nb0_py = """# <nbformat>2</nbformat>
 
 # <codecell>
 
 import numpy
 
 # </codecell>
 # <codecell>
 
 a = numpy.random.rand(100)
 
 # </codecell>
 # <codecell>
 
 print a
 
 # </codecell>
 """
 
 

IPython/nbformat/v2/tests/test_nbbase.py

@@ -1,66 +1,79 b''
 from unittest import TestCase
 
 from ..nbbase import (
     NotebookNode,
-    new_code_cell, new_html_cell, new_worksheet, new_notebook, new_output
+    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, [])
 
     def test_code_cell(self):
         cc = new_code_cell(input='a=10', prompt_number=0)
         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)
 
     def test_empty_html_cell(self):
-        tc = new_html_cell()
-        self.assertEquals(tc.cell_type, 'html')
+        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_html_cell('hi')
+        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_html_cell()]
+        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)
 

IPython/nbformat/v2/tests/test_nbpy.py

@@ -1,17 +1,17 b''
 from unittest import TestCase
 
 from ..nbbase import (
     NotebookNode,
-    new_code_cell, new_html_cell, new_worksheet, new_notebook
+    new_code_cell, new_text_cell, new_worksheet, new_notebook
 )
 
 from ..nbpy import reads, writes
 from .nbexamples import nb0, nb0_py
 
 
 class TestPy(TestCase):
 
     def test_write(self):
         s = writes(nb0)
         self.assertEquals(s,nb0_py)