def test_upgrade_downgrade_4_3_4(self):
"""Test that a v4 notebook downgraded to v3 and then upgraded to v4
passes validation tests"""
with self.fopen("test4.ipynb", "r") as f:
nb = read(f)
validate(nb)
nb = convert(nb, 3)
validate(nb)
nb = convert(nb, 4)
self.assertEqual(isvalid(nb), True)
def _test_notebook(self, notebook, test):
with open(notebook) as f:
nb = convert(reads(f.read()), self.NBFORMAT_VERSION)
_, kernel = utils.start_new_kernel()
for i, c in enumerate([c for c in nb.cells if c.cell_type == 'code']):
self._test_notebook_cell(self.sanitize_cell(c), i, kernel, test)
def refresh(self, on_changed=False):
'''Reload the notebook from file and compile cells.'''
# only refresh if the file has updated
ts = os.stat(self.nb_path).st_mtime
if on_changed:
dtstr = datetime.datetime.fromtimestamp(ts).strftime('%m/%d/%Y %H:%M:%S')
if ts == self.timestamp:
# print('Notebook has not changed since {}'.format(dtstr))
return self
else:
print('Notebook last updated at {}. Refreshing.'.format(dtstr))
self.timestamp = ts
self.cells = []
self.md_tags = []
self.block_tag = None
with io.open(self.nb_path, 'r', encoding='utf-8') as f:
notebook = reader.read(f)
# convert to current notebook version
notebook = converter.convert(notebook, current_nbformat)
self.compiler = CachingCompiler()
for i, cell in enumerate(notebook.cells):
if cell.cell_type == 'markdown' and self.md_parser:
self._markdown_tags(cell)
elif cell.cell_type == 'code' and cell.source:
source = self._compile_code(cell.source, i)
self.cells.append({'source': cell.source, 'code': source,
'tags': self._cell_tags(cell),
'md_tags': tuple(self.md_tags)})
return self
def _test_notebook(self, notebook, test):
with open(notebook) as f:
nb = convert(reads(f.read()), self.NBFORMAT_VERSION)
_, kernel = utils.start_new_kernel()
for i, c in enumerate([c for c in nb.cells if c.cell_type == 'code']):
self._test_notebook_cell(self.sanitize_cell(c), i, kernel, test)
def readnb(self, filename):
try:
nb = self._readnb(filename)
except Exception as err:
log.info("could not be parse as a notebook %s\n%s", filename, err)
return False
return convert(nb, NBFORMAT_VERSION)
def read_notebook(fn):
from nbformat.converter import convert
from nbformat.reader import reads
IPYTHON_VERSION = 4
NBFORMAT_VERSION = 4
with open(fn, 'r') as f:
text = f.read()
data = reads(text)
return text, convert(data, NBFORMAT_VERSION)
def readnb(self, filename):
try:
nb = self._readnb(filename)
except Exception as err:
log.info("could not be parse as a notebook %s\n%s",
filename,
err)
return False
return convert(nb, NBFORMAT_VERSION)
def test_upgrade_2_3(self):
"""Do notebook upgrades work?"""
# Open a version 2 notebook and attempt to upgrade it to version 3.
with self.fopen("test2.ipynb", "r") as f:
nb = read(f)
nb = convert(nb, 3)
# Check if upgrade was successful.
(major, minor) = get_version(nb)
self.assertEqual(major, 3)
def test_downgrade_3_2(self):
"""Do notebook downgrades work?"""
# Open a version 3 notebook and attempt to downgrade it to version 2.
with self.fopen("test3.ipynb", "r") as f:
nb = read(f)
nb = convert(nb, 2)
# Check if downgrade was successful.
(major, minor) = get_version(nb)
self.assertEqual(major, 2)
def test_open_current(self):
"""Can an old notebook be opened and converted to the current version
while remembering the original version of the notebook?"""
# Open a version 2 notebook and attempt to upgrade it to the current version
# while remembering it's version information.
with self.fopen("test2.ipynb", "r") as f:
nb = read(f)
(original_major, original_minor) = get_version(nb)
nb = convert(nb, current_nbformat)
# Check if upgrade was successful.
(major, minor) = get_version(nb)
self.assertEqual(major, current_nbformat)
# Check if the original major revision was remembered.
self.assertEqual(original_major, 2)
def test_upgrade_3_4__missing_metadata(self):
with self.fopen("test3_no_metadata.ipynb", "r") as f:
nb = read(f)
with self.assertRaisesRegex(ValidationError, r"could not be converted.+metadata"):
convert(nb, 4)
def convert_notebook(notebook):
'''Converts IPython notebook to current version.'''
return converter.convert(notebook, nbformat.current_nbformat)
def convert_notebook(notebook):
'''Converts IPython notebook to current version.'''
return converter.convert(notebook, nbformat.current_nbformat)
return text + "\n# <markdowncell>\n\n# Bugfix\n"
adjust_from_map = {
("py_v3", "json"): pad_markdown,
}
parser = argparse.ArgumentParser()
parser.add_argument("--to", type=str, choices=choices, default="json")
parser.add_argument("--from",
dest="from_",
type=str,
choices=choices,
default="py_v3")
parser.add_argument("input", type=argparse.FileType('r'))
parser.add_argument("output", type=argparse.FileType('w'))
args = parser.parse_args()
(v_from, m_from) = conversions[args.from_]
(v_out, m_to) = conversions[args.to]
adjust_from = adjust_from_map.get((args.from_, args.to))
text_from = args.input.read()
if adjust_from is not None:
text_from = adjust_from(text_from)
nb_from = m_from.reads(text_from)
if v_from != v_out:
nb_from = convert(nb_from, to_version=v_out)
m_to.write(nb_from, args.output)
