Starting to rename text cell to html cell.

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_text_cell, new_notebook, new_output, new_worksheet
+    new_code_cell, new_html_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_text_cell, new_notebook, new_output, new_worksheet
+    new_code_cell, new_html_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_text_cell, new_worksheet, new_notebook, new_output
+    new_code_cell, new_html_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':
                 newcell = new_code_cell(input=cell.get('code'),prompt_number=cell.get('prompt_number'))
             elif cell.cell_type == 'text':
-                newcell = new_text_cell(text=cell.get('text'))
+                newcell = new_html_cell(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,104 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_text_cell(text=None):
+def new_html_cell(source=None):
     """Create a new text cell."""
     cell = NotebookNode()
-    if text is not None:
-        cell.text = unicode(text)
-    cell.cell_type = u'text'
+    if source is not None:
+        cell.source = unicode(source)
+    cell.cell_type = u'html'
     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,168 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
+    new_code_cell, new_html_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'):
-                        prompt_number = _get_int(output_e,'prompt_number')
+                        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=prompt_number
+                            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 == 'textcell':
-                    text = _get_text(cell_e,'text')
-                    cells.append(new_text_cell(text=text))
+                if cell_e.tag == 'htmlcell':
+                    source = _get_text(cell_e,'source')
+                    cells.append(new_html_cell(source=source))
             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(cell,'prompt_number',output_e,'prompt_number')
+                        _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 == 'text':
-                    cell_e = ET.SubElement(cells_e, 'textcell')
-                    _set_text(cell,'text',cell_e,'text')
+                elif cell_type == 'html':
+                    cell_e = ET.SubElement(cells_e, 'htmlcell')
+                    _set_text(cell,'source',cell_e,'source')
 
         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,73 +1,75 b''
 from ..nbbase import (
     NotebookNode,
-    new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output
+    new_code_cell, new_html_cell, new_worksheet, new_notebook, new_output
 )
 
 
 
 ws = new_worksheet(name='worksheet1')
 
-ws.cells.append(new_text_cell(
-    text='Some NumPy Examples'
+ws.cells.append(new_html_cell(
+    source='Some NumPy Examples'
 ))
 
 
 ws.cells.append(new_code_cell(
     input='import numpy',
     prompt_number=1
 ))
 
 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;'
+        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;'
+        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,64 +1,66 b''
 from unittest import TestCase
 
 from ..nbbase import (
     NotebookNode,
-    new_code_cell, new_text_cell, new_worksheet, new_notebook, new_output
+    new_code_cell, new_html_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')]
+        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_text_cell(self):
-        tc = new_text_cell()
-        self.assertEquals(tc.cell_type, 'text')
-        self.assertEquals('text' not in tc, True)
+    def test_empty_html_cell(self):
+        tc = new_html_cell()
+        self.assertEquals(tc.cell_type, 'html')
+        self.assertEquals('source' not in tc, True)
 
-    def test_text_cell(self):
-        tc = new_text_cell('hi')
-        self.assertEquals(tc.text, u'hi')
+    def test_html_cell(self):
+        tc = new_html_cell('hi')
+        self.assertEquals(tc.source, 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()]
+        cells = [new_code_cell(), new_html_cell()]
         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_text_cell, new_worksheet, new_notebook
+    new_code_cell, new_html_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)