def test_read(self):
"""Can older notebooks be opened without modification?"""
# Open a version 3 notebook. Make sure it is still version 3.
with self.fopen("test3.ipynb", "r") as f:
nb = read(f)
(major, minor) = get_version(nb)
self.assertEqual(major, 3)
# Open a version 2 notebook. Make sure it is still version 2.
with self.fopen("test2.ipynb", "r") as f:
nb = read(f)
(major, minor) = get_version(nb)
self.assertEqual(major, 2)
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 load_module_by_path(self):
# parse the notebook json
with io.open(self.nb_path, 'r', encoding='utf-8') as f:
notebook = reader.read(f)
# convert to current notebook version
notebook = convert_notebook(notebook)
# create the module and generate a hash from the name
fullname = hashlib.sha1().hexdigest()
mod = types.ModuleType(fullname)
mod.__file__ = self.nb_path
mod.__package__ = None
mod.__loader__ = self
sys.modules[fullname] = mod
# extra work to ensure that magics that would affect the user_ns
# actually affect the notebook module's ns
save_user_ns = self.shell.user_ns
self.shell.user_ns = mod.__dict__
try:
self.eval_notebook(notebook, mod)
finally:
self.shell.user_ns = save_user_ns
return mod
def load_module(self, fullname):
'''
Creates a module containing the exposed API content of a notebook
by evaluating those notebook cells.
'''
# parse the notebook json
with io.open(self.nb_path, 'r', encoding='utf-8') as f:
notebook = reader.read(f)
# convert to current notebook version
notebook = convert_notebook(notebook)
# create the module
mod = types.ModuleType(fullname)
mod.__file__ = self.nb_path
mod.__package__ = '.'.join(fullname.split('.')[:-1])
mod.__loader__ = self
sys.modules[fullname] = mod
# extra work to ensure that magics that would affect the user_ns
# actually affect the notebook module's ns
save_user_ns = self.shell.user_ns
self.shell.user_ns = mod.__dict__
try:
self.eval_notebook(notebook, mod)
finally:
self.shell.user_ns = save_user_ns
return mod
def load_module_by_path(self):
# parse the notebook json
with io.open(self.nb_path, 'r', encoding='utf-8') as f:
notebook = reader.read(f)
# convert to current notebook version
notebook = convert_notebook(notebook)
# create the module and generate a hash from the name
fullname = hashlib.sha1().hexdigest()
mod = types.ModuleType(fullname)
mod.__file__ = self.nb_path
mod.__package__ = None
mod.__loader__ = self
sys.modules[fullname] = mod
# extra work to ensure that magics that would affect the user_ns
# actually affect the notebook module's ns
save_user_ns = self.shell.user_ns
self.shell.user_ns = mod.__dict__
try:
self.eval_notebook(notebook, mod)
finally:
self.shell.user_ns = save_user_ns
return mod
def load_module(self, fullname):
'''
Creates a module containing the exposed API content of a notebook
by evaluating those notebook cells.
'''
# parse the notebook json
with io.open(self.nb_path, 'r', encoding='utf-8') as f:
notebook = reader.read(f)
# convert to current notebook version
notebook = convert_notebook(notebook)
# create the module
mod = types.ModuleType(fullname)
mod.__file__ = self.nb_path
mod.__package__ = '.'.join(fullname.split('.')[:-1])
mod.__loader__ = self
sys.modules[fullname] = mod
# extra work to ensure that magics that would affect the user_ns
# actually affect the notebook module's ns
save_user_ns = self.shell.user_ns
self.shell.user_ns = mod.__dict__
try:
self.eval_notebook(notebook, mod)
finally:
self.shell.user_ns = save_user_ns
return mod
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_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 execute_notebook(nbfile, silent=True):
"""
execute a notebook file
Args:
nbfile: the filename
silent: should output be hidden.
Returns: Nothing
"""
with io.open(nbfile) as f:
nb = reader.read(f)
ip = get_ipython()
for cell in nb.cells:
if cell.cell_type != 'code':
continue
ip.run_cell(cell.source, silent=silent)
def execute_notebook(nbfile, silent=True):
"""
execute a notebook file
Args:
nbfile: the filename
silent: should output be hidden.
Returns: Nothing
"""
with io.open(nbfile) as f:
nb = reader.read(f)
ip = get_ipython()
for cell in nb.cells:
if cell.cell_type != 'code':
continue
ip.run_cell(cell.source, silent=silent)
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 test_read_fails_on_missing_worksheet_cells(self):
with self.fopen("test3_worksheet_with_no_cells.ipynb", "r") as f:
with self.assertRaisesRegex(ValidationError, r"cells"):
nb = read(f)
