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 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 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)
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)