|
|
"""Read and write notebook files as XML.
|
|
|
|
|
|
Authors:
|
|
|
|
|
|
* Brian Granger
|
|
|
"""
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Copyright (C) 2008-2011 The IPython Development Team
|
|
|
#
|
|
|
# Distributed under the terms of the BSD License. The full license is in
|
|
|
# the file COPYING, distributed as part of this software.
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Imports
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
from base64 import encodestring, decodestring
|
|
|
import warnings
|
|
|
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_metadata
|
|
|
)
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
|
# Code
|
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
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):
|
|
|
warnings.warn('The XML notebook format is no longer supported, '
|
|
|
'please convert your notebooks to JSON.', DeprecationWarning)
|
|
|
nbname = _get_text(root,u'name')
|
|
|
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(u'worksheets').getiterator(u'worksheet'):
|
|
|
wsname = _get_text(ws_e,u'name')
|
|
|
cells = []
|
|
|
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(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,
|
|
|
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 == 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 == 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)
|
|
|
|
|
|
md = new_metadata(name=nbname)
|
|
|
nb = new_notebook(metadata=md,worksheets=worksheets)
|
|
|
return nb
|
|
|
|
|
|
|
|
|
_reader = XMLReader()
|
|
|
|
|
|
reads = _reader.reads
|
|
|
read = _reader.read
|
|
|
to_notebook = _reader.to_notebook
|
|
|
|
|
|
|
