def test_write_reload_simple_notebook(): nb1 = new_notebook(cells=[ new_markdown_cell('A markdown cell', metadata={'md': 'value'}), new_code_cell('1 + 1'), new_markdown_cell('A markdown cell', metadata={'md': 'value'}), new_code_cell("""def f(x): return x""", metadata={'md': 'value'}), new_markdown_cell('A markdown cell', metadata={'md': 'value'}), new_code_cell("""def g(x): return x def h(x): return x """, metadata={'md': 'value'}) ]) text = writes(nb1, 'py:bare') nb2 = reads(text, 'py:bare') combine_inputs_with_outputs(nb2, nb1, 'py:bare') nb2.metadata.pop('jupytext') assert len(nb2.cells) == 7 nb1.cells = nb1.cells[:5] nb2.cells = nb2.cells[:5] compare(nb1, nb2)
def test_ipython_help_are_commented_297(text="""# This is a markdown cell # that ends with a question: float? # The next cell is also a markdown cell, # because it has no code marker: # float? # + # float? # + # float?? # + # Finally a question in a code # # cell? """, nb=new_notebook( cells=[ new_markdown_cell('This is a markdown cell\nthat ends with a question: float?'), new_markdown_cell('The next cell is also a markdown cell,\nbecause it has no code marker:'), new_markdown_cell('float?'), new_code_cell('float?'), new_code_cell('float??'), new_code_cell('# Finally a question in a code\n# cell?')])): nb2 = jupytext.reads(text, 'py') compare_notebooks(nb2, nb) text2 = jupytext.writes(nb2, 'py') compare(text2, text)
def notebook_expected(): return new_notebook(metadata=notebook_metadata(), cells=[ new_markdown_cell('First markdown cell'), new_code_cell('1 + 1'), new_markdown_cell('Second markdown cell') ])
def test_combine_reorder(): nb_source = new_notebook( cells=[ new_markdown_cell("Markdown text"), new_code_cell("1+1"), new_code_cell("2+2"), new_code_cell("3+3"), new_markdown_cell("Markdown text"), new_code_cell("4+4"), ] ) nb_outputs = new_notebook( cells=[ new_markdown_cell("Markdown text"), new_code_cell("2+2"), new_code_cell("4+4"), new_code_cell("1+1"), new_code_cell("3+3"), new_markdown_cell("Markdown text"), ] ) nb_outputs.cells[1].outputs = ["4"] nb_outputs.cells[2].outputs = ["8"] nb_outputs.cells[3].outputs = ["2"] nb_outputs.cells[4].outputs = ["6"] nb_source = combine_inputs_with_outputs(nb_source, nb_outputs) assert nb_source.cells[1].outputs == ["2"] assert nb_source.cells[2].outputs == ["4"] assert nb_source.cells[3].outputs == ["6"] assert nb_source.cells[5].outputs == ["8"]
def test_rst2md(tmpdir): tmp_py = str(tmpdir.join("notebook.py")) tmp_ipynb = str(tmpdir.join("notebook.ipynb")) # Write notebook in sphinx format nb = new_notebook(cells=[ new_markdown_cell("A short sphinx notebook"), new_markdown_cell(":math:`1+1`"), ]) write(nb, tmp_py, fmt="py:sphinx") jupytext([ tmp_py, "--from", "py:sphinx", "--to", "ipynb", "--opt", "rst2md=True", "--opt", "cell_metadata_filter=-all", ]) assert os.path.isfile(tmp_ipynb) nb = read(tmp_ipynb) assert nb.metadata["jupytext"]["cell_metadata_filter"] == "-all" assert nb.metadata["jupytext"]["rst2md"] is False # Was rst to md conversion effective? assert nb.cells[2].source == "$1+1$"
def test_raise_on_different_cell_content(): ref = new_notebook(cells=[new_markdown_cell('Cell one'), new_code_cell('Cell two')]) test = new_notebook(cells=[new_markdown_cell('Cell one'), new_code_cell('Modified cell two')]) with pytest.raises(AssertionError): compare_notebooks(ref, test)
def test_combine(): nb_source = new_notebook( cells=[ new_markdown_cell("Markdown text"), new_code_cell("a=3"), new_code_cell("a+1"), new_code_cell("a+1"), new_markdown_cell("Markdown text"), new_code_cell("a+2"), ] ) nb_outputs = new_notebook( cells=[ new_markdown_cell("Markdown text"), new_code_cell("a=3"), new_code_cell("a+1"), new_code_cell("a+2"), new_markdown_cell("Markdown text"), ] ) nb_outputs.cells[2].outputs = ["4"] nb_outputs.cells[3].outputs = ["5"] nb_source = combine_inputs_with_outputs(nb_source, nb_outputs) assert nb_source.cells[2].outputs == ["4"] assert nb_source.cells[3].outputs == [] assert nb_source.cells[5].outputs == ["5"]
def add_badges(path_to_notes: str = None, badges: list = None) -> None: """Adds badges to each notebook in the collection. Adds a badge cell with one or more badges to each notebook in the collection of indexed notebooks in the folder `path_to_notes`. The information for creating each badge is in the list `badges`. Parameters ---------- path_to_notes : str The path to the directory that contains the notebooks, either absolute or relative to the script that calls `nbbinder.bind()`. badges: list of dict A list of dictionaries with the necessary information to add the badges. Each item in the list is a dictionary which should have the keys `alt` (str), `title` (str), `url` (str), an optional `extension` (str), and either `src` or the three keys `label` (str), `message` (str), and `color` (str). The key `url` is used for building link address, with the `href` argument being composed of the given `url` appended by the nam of the corresponding notebook. The keys `label`, `message`, and `color` are used to build the badge image via the `shields.io` constructor, which will then become the argument `src` of the badge image. Alternatively, one can provide a direct `src` link to the badge image. The keys `alt` and `title` complement the information of the image. The key `extension` is used in case there is a need to replace the `.ipynb` extension of each notebook to the appropriate extension, e.g `.md`, `.slides.html`, `.pdf`, `.py`, `.tex`, and so on. If `extension` is omitted, no replacement occurs. """ cleanup_marker_cells(path_to_notes, BADGES_MARKER, 'remove') for nb_filename, this_nb_badge_links \ in get_badge_entries(path_to_notes, badges): nb = nbformat.read(nb_filename, as_version=4) nb_name = os.path.basename(nb_filename) badges_top = BADGES_MARKER + "\n" for badge_link in this_nb_badge_links: badges_top += badge_link + " " if not nb.cells or not nb.cells[0].source.startswith(HEADER_MARKER): LOGGER.info("- inserting badges for %s", nb_name) nb.cells.insert(0, new_markdown_cell(source=badges_top, metadata=SLIDE_SKIP)) else: LOGGER.info("- inserting badges for %s", nb_name) nb.cells.insert(1, new_markdown_cell(source=badges_top, metadata=SLIDE_SKIP)) nbformat.write(nb, nb_filename)
def test_combine(): nb_source = new_notebook(cells=[ new_markdown_cell('Markdown text'), new_code_cell('a=3'), new_code_cell('a+1'), new_code_cell('a+1'), new_markdown_cell('Markdown text'), new_code_cell('a+2') ]) nb_outputs = new_notebook(cells=[ new_markdown_cell('Markdown text'), new_code_cell('a=3'), new_code_cell('a+1'), new_code_cell('a+2'), new_markdown_cell('Markdown text') ]) nb_outputs.cells[2].outputs = ['4'] nb_outputs.cells[3].outputs = ['5'] combine_inputs_with_outputs(nb_source, nb_outputs) assert nb_source.cells[2].outputs == ['4'] assert nb_source.cells[3].outputs == [] assert nb_source.cells[5].outputs == ['5']
def test_raise_on_different_metadata(): ref = new_notebook(metadata={'main_language': 'python'}, cells=[new_markdown_cell('Cell one')]) test = new_notebook(metadata={'main_language': 'R'}, cells=[new_markdown_cell('Cell one')]) with pytest.raises(AssertionError): compare_notebooks(ref, test)
def test_alert_inconsistent_versions(tmpdir, cwd_tmpdir, tmp_repo, capsys): """Jupytext refuses to sync two inconsistent notebooks""" write(new_notebook(cells=[new_markdown_cell("A short py notebook")]), "test.py") write( new_notebook( cells=[new_markdown_cell("Another ipynb notebook")], metadata={"jupytext": { "formats": "ipynb,py" }}, ), "test.ipynb", ) # Add them both tmp_repo.git.add("test.py") tmp_repo.git.add("test.ipynb") # Run jupytext status = jupytext(["--sync", "--pre-commit-mode", "test.ipynb"]) # The diff should be visible assert status == 1 out = capsys.readouterr() assert ("""--- test.py +++ test.ipynb""" in out.err) assert """-# A short py notebook +# Another ipynb notebook """ assert "Error: test.ipynb and test.py are inconsistent" in out.err assert "git reset test.py && git checkout -- test.py" in out.err assert "git reset test.ipynb && git checkout -- test.ipynb" in out.err
def test_raise_on_different_metadata(): ref = new_notebook(metadata={'kernelspec': {'language': 'python', 'name': 'python', 'display_name': 'Python'}}, cells=[new_markdown_cell('Cell one')]) test = new_notebook(metadata={'kernelspec': {'language': 'R', 'name': 'R', 'display_name': 'R'}}, cells=[new_markdown_cell('Cell one')]) with pytest.raises(NotebookDifference): compare_notebooks(test, ref, 'md')
def test_does_not_raise_on_split_markdown_cell(): ref = new_notebook(cells=[new_markdown_cell('Cell one\n\n\nsecond line')]) test = new_notebook(cells=[ new_markdown_cell('Cell one'), new_markdown_cell('second line') ]) compare_notebooks(ref, test, ext='.md')
def test_raise_on_different_cell_count(): ref = new_notebook( cells=[new_markdown_cell('Cell one'), new_code_cell('Cell two')]) test = new_notebook(cells=[new_markdown_cell('Cell one')]) with pytest.raises(NotebookDifference): compare_notebooks(ref, test, ext='.md')
def test_does_raise_on_split_markdown_cell(): ref = new_notebook(cells=[new_markdown_cell('Cell one\n\n\nsecond line')]) test = new_notebook(cells=[ new_markdown_cell('Cell one'), new_markdown_cell('second line') ]) with pytest.raises(NotebookDifference): compare_notebooks(ref, test, 'md')
def notebook_2(): metadata = notebook_metadata() metadata['language_info']['version'] = '3.6.8' return new_notebook( metadata=metadata, cells=[new_markdown_cell('First markdown cell'), new_code_cell('1 + 1'), new_markdown_cell('Modified markdown cell')])
def test_does_raise_on_split_markdown_cell(): ref = new_notebook(cells=[new_markdown_cell("Cell one\n\n\nsecond line")]) test = new_notebook(cells=[ new_markdown_cell("Cell one"), new_markdown_cell("second line") ]) with pytest.raises(NotebookDifference): compare_notebooks(test, ref, "md")
def test_raise_on_split_markdown_cell(): ref = new_notebook(cells=[new_markdown_cell('Cell one\n\n\nsecond line')]) test = new_notebook(cells=[ new_markdown_cell('Cell one'), new_markdown_cell('second line') ]) with pytest.raises(AssertionError): compare_notebooks(ref, test)
def test_pre_commit_hook_ipynb_to_py(tmpdir, cwd_tmpdir, tmp_repo, jupytext_repo_root, jupytext_repo_rev): """Here we document and test the expected behavior of the pre-commit hook in the directional (--to) mode. Note that here, the ipynb file is always the source for updates - i.e. changes on the .py file will not trigger the hook. """ # set up the tmpdir repo with pre-commit pre_commit_config_yaml = f""" repos: - repo: {jupytext_repo_root} rev: {jupytext_repo_rev} hooks: - id: jupytext args: [--from, ipynb, --to, "py:percent"] """ tmpdir.join(".pre-commit-config.yaml").write(pre_commit_config_yaml) tmp_repo.git.add(".pre-commit-config.yaml") pre_commit(["install", "--install-hooks"]) # write test notebook and output file nb = new_notebook(cells=[new_markdown_cell("A short notebook")]) write(nb, "test.ipynb") jupytext(["--from", "ipynb", "--to", "py:percent", "test.ipynb"]) tmp_repo.git.add(".") tmp_repo.index.commit("test") # make a change to the notebook nb = new_notebook(cells=[new_markdown_cell("Some other text")]) write(nb, "test.ipynb") tmp_repo.git.add("test.ipynb") # now a commit will fail, and keep failing until we add the new # changes made to the existing output to the index ourselves with pytest.raises(HookExecutionError, match="files were modified by this hook"): tmp_repo.index.commit("fails") with pytest.raises(HookExecutionError, match="git add test.py"): tmp_repo.index.commit("fails again") # once we add the changes, it will pass tmp_repo.git.add("test.py") tmp_repo.index.commit("succeeds") assert "test.ipynb" in tmp_repo.tree() assert "test.py" in tmp_repo.tree() # Updating the .py file is possible nb = new_notebook(cells=[new_markdown_cell("Some updated text")]) write(nb, "test.py", fmt="py:percent") tmp_repo.index.commit("update py version") # But it won't change the ipynb file (if you want that, use the --sync mode) nb = read("test.ipynb") compare_cells(nb.cells, [new_markdown_cell("Some other text")], compare_ids=False)
def write_index(notebook_directory, index_dict, kernel='python3'): index_listing = '\n'.join('- ' + entry for key, entry in sorted(index_dict.items())) cells = [new_markdown_cell(INDEX_TEXT), new_markdown_cell(index_listing)] write_notebook(cells, os.path.join(notebook_directory, 'Index.ipynb'), execute=False, kernel=kernel)
def notebook_expected(): return new_notebook( metadata=notebook_metadata(), cells=[ new_markdown_cell("First markdown cell"), new_code_cell("1 + 1"), new_markdown_cell("Second markdown cell"), ], )
def notebook_expected(): return new_notebook( metadata=notebook_metadata(), cells=[ new_markdown_cell("First markdown cell", id="markdown-cell-one"), new_code_cell("1 + 1", id="code-cell-one"), new_markdown_cell("Second markdown cell", id="markdown-cell-two"), ], )
def test_read_simple_file(script="""# --- # title: Simple file # --- # %% [markdown] # This is a markdown cell # %% [md] # This is also a markdown cell # %% [raw] # This is a raw cell # %%% sub-cell title # This is a sub-cell # %%%% sub-sub-cell title # This is a sub-sub-cell # %% And now a code cell 1 + 2 + 3 + 4 5 6 # %%magic # this is a commented magic, not a cell 7 """): nb = jupytext.reads(script, 'py:percent') compare_notebooks( new_notebook(cells=[ new_raw_cell('---\ntitle: Simple file\n---'), new_markdown_cell('This is a markdown cell'), new_markdown_cell('This is also a markdown cell', metadata={'region_name': 'md'}), new_raw_cell('This is a raw cell'), new_code_cell('# This is a sub-cell', metadata={ 'title': 'sub-cell title', 'cell_depth': 1 }), new_code_cell('# This is a sub-sub-cell', metadata={ 'title': 'sub-sub-cell title', 'cell_depth': 2 }), new_code_cell('''1 + 2 + 3 + 4 5 6 %%magic # this is a commented magic, not a cell 7''', metadata={'title': 'And now a code cell'}) ]), nb) script2 = jupytext.writes(nb, 'py:percent') compare(script2, script)
def test_two_markdown_cell_with_no_language_code_works(nb=new_notebook(cells=[ new_markdown_cell("""``` 1 + 1 ```"""), new_markdown_cell("""``` 2 + 2 ```""") ])): text = jupytext.writes(nb, 'md') nb2 = jupytext.reads(text, 'md') compare_notebooks(nb2, nb)
def test_does_raise_on_split_markdown_cell(): ref = new_notebook(cells=[new_markdown_cell('Cell one\n\n\nsecond line')]) test = new_notebook(cells=[ new_markdown_cell('Cell one'), new_markdown_cell('second line') ]) with pytest.raises(NotebookDifference): compare_notebooks(ref, test, ext='.md', allow_expected_differences=False)
def write_navbars(): for nb_name, navbar in iter_navbars(): nb = nbformat.read(nb_name, as_version=4) nb_file = os.path.basename(nb_name) is_comment = lambda cell: cell.source.startswith(NAV_COMMENT) exercises = get_notebook_exercises(nb) n = len(exercises) if n > 0: exercise_links = [ "[%s](<#%s>)" % (e, to_github(e)) for e in exercises ] longest_field = max(len(e) for e in exercise_links) print(exercise_links) print("%i exercises" % n) columns = 3 if n < columns: columns = n table = [] empty = " " * (longest_field + 2) column_title = "-".center(longest_field + 2) dash = "-" * (longest_field + 2) table.append("|%s\n" % (("%s|" % column_title) * columns)) # No column title table.append("|%s\n" % (("%s|" % dash) * columns)) # separator line for i, e in enumerate(exercise_links): if i % columns == 0: # Start a new row table.append("|") table.append(" %s |" % e.center(longest_field)) if i % columns == (columns - 1): # Row is full table.append("\n") remainder = n % columns if remainder > 0: table.append("%s\n" % (("%s|" % empty) * (columns - remainder))) table = "".join(table) print(table) header = "%s\n%s\n" % (navbar, table) else: header = "%s\n" % (navbar) # no exercises if is_comment(nb.cells[0]): print("- amending navbar for {0}".format(nb_file)) nb.cells[0].source = header else: print("- inserting navbar for {0}".format(nb_file)) nb.cells.insert(0, new_markdown_cell(source=header)) if is_comment(nb.cells[-1]): nb.cells[-1].source = navbar else: nb.cells.append(new_markdown_cell(source=navbar)) nbformat.write(nb, nb_name)
def notebook_actual(): metadata = notebook_metadata() metadata["language_info"]["version"] = "3.6.8" return new_notebook( metadata=metadata, cells=[ new_markdown_cell("First markdown cell"), new_code_cell("1 + 1"), new_markdown_cell("Modified markdown cell"), ], )
def test_two_markdown_cell_with_code_works(nb=new_notebook(cells=[ new_markdown_cell("""```python 1 + 1 ```"""), new_markdown_cell("""```python 2 + 2 ```"""), ])): text = jupytext.writes(nb, "Rmd") nb2 = jupytext.reads(text, "Rmd") compare_notebooks(nb2, nb)
def test_notebook_with_empty_cells(blank_cells): notebook = new_notebook(cells=[new_markdown_cell('markdown cell one')] + [new_code_cell('')] * blank_cells + [new_markdown_cell('markdown cell two')] + [new_code_cell('')] * blank_cells, metadata={'main_language': 'python'}) script = jupytext.writes(notebook, ext='.py') notebook2 = jupytext.reads(script, ext='.py') compare(notebook, notebook2)
def test_raise_on_different_metadata(): ref = new_notebook(metadata={'language_info': { 'name': 'python' }}, cells=[new_markdown_cell('Cell one')]) test = new_notebook(metadata={'language_info': { 'name': 'R' }}, cells=[new_markdown_cell('Cell one')]) with pytest.raises(NotebookDifference): compare_notebooks(ref, test, ext='.md')
def make_nb(config, path=None, stop_on_error=True, just_tests=False): """Create a Jupyter notebook sciunit tests for the given configuration.""" root, nb_name = nb_name_from_path(config, path) clean = lambda varStr: re.sub('\W|^(?=\d)', '_', varStr) name = clean(nb_name) mpl_style = config.get('misc', 'matplotlib', fallback='inline') cells = [new_markdown_cell('## Sciunit Testing Notebook for %s' % nb_name)] add_code_cell(cells, ( "%%matplotlib %s\n" "from IPython.display import display\n" "from importlib.machinery import SourceFileLoader\n" "%s = SourceFileLoader('scidash', '%s/__init__.py').load_module()") % (mpl_style, name, root)) if just_tests: add_code_cell(cells, ( "for test in %s.tests.tests:\n" " score_array = test.judge(%s.models.models, stop_on_error=%r)\n" " display(score_array)") % (name, name, stop_on_error)) else: add_code_cell(cells, ( "for suite in %s.suites.suites:\n" " score_matrix = suite.judge(" "%s.models.models, stop_on_error=%r)\n" " display(score_matrix)") % (name, name, stop_on_error)) write_nb(root, nb_name, cells)
def write_header(self): if self.content.cells[0].source.startswith(NOTEBOOK_HEADER_TAG): print('- amending header for {0}'.format(self.filename)) self.content.cells[0].source = NOTEBOOK_HEADER else: print('- inserting header for {0}'.format(self.filename)) self.content.cells.insert(0, new_markdown_cell(NOTEBOOK_HEADER)) nbformat.write(self.content, self.path)
def write_navbar(self): for cell in [self.content.cells[1], self.content.cells[-1]]: if cell.source.startswith(NAVBAR_TAG): print(f"- amending navbar for {self.filename}") cell.source = self.navbar else: print(f"- inserting navbar for {self.filename}") self.content.cells.insert(1, new_markdown_cell(source=self.navbar)) nbformat.write(self.content, self.path)
def write_navbars(): for nb_name, navbar in iter_navbars(): nb = nbformat.read(nb_name, as_version=4) nb_file = os.path.basename(nb_name) is_comment = lambda cell: cell.source.startswith(NAV_COMMENT) if is_comment(nb.cells[1]): print("- amending navbar for {0}".format(nb_file)) nb.cells[1].source = navbar else: print("- inserting navbar for {0}".format(nb_file)) nb.cells.insert(1, new_markdown_cell(source=navbar)) if is_comment(nb.cells[-1]): nb.cells[-1].source = navbar else: nb.cells.append(new_markdown_cell(source=navbar)) nbformat.write(nb, nb_name)
def test_notebook(name): """ Make a test notebook for the given name. """ nb = new_notebook() nb.cells.append(new_code_cell("'code_' + '{}'".format(name))) nb.cells.append(new_raw_cell("raw_{}".format(name))) nb.cells.append(new_markdown_cell("markdown_{}".format(name))) return nb
def cells(): yield new_markdown_cell('<small>*Notebook auto-generated from ' '[``{0}``]({1})*</small>\n\n' '# Altair Example: {2}\n\n' '{3}\n\n'.format(full_filename, full_filepath, title, description)) yield new_code_cell('# Uncomment and run these two lines to enable rendering in JupyterLab/nteract\n' '# from altair import enable_mime_rendering\n' '# enable_mime_rendering()') yield new_markdown_cell('## Load Dataset\n' 'The data comes in the form of a Pandas ' 'Dataframe:') yield new_code_cell('from altair import load_dataset\n' 'data = load_dataset("{0}")\n' 'data.head()'.format(dataset)) yield new_markdown_cell('## Define Altair Specification') yield new_code_cell(''.join(['from altair import * # Import the altair API\n\n', 'chart = {0}\n\n'.format(chart.to_altair(data='data')), 'chart.max_rows = len(data) # Altair 1.2.1 has a max_rows of 500 by default'])) yield new_markdown_cell('IPython rich display will invoke Vega-Lite:') yield new_code_cell('chart') yield new_markdown_cell('## Output Vega-Lite Specification') yield new_markdown_cell('Generate JSON dict, leaving data out:') yield new_code_cell('chart.to_dict(data=False)')
def create_doc_notebook(filename): kernelspec = {'display_name': 'Python 3', 'language': 'python', 'name': 'python3'} is_toplevel = lambda obj: 'Chart' in obj['name'] content = sorted(altair_nbdoc(altair), key=itemgetter('name')) cells = [new_markdown_cell(source=(HEADER))] cells.append(new_markdown_cell(source='## Top-Level Objects')) cells.extend([new_markdown_cell(source=TEMPLATE.render(obj=obj)) for obj in filter(is_toplevel, content)]) cells.append(new_markdown_cell(source='## Other Objects')) cells.extend([new_markdown_cell(source=TEMPLATE.render(obj=obj)) for obj in filterfalse(is_toplevel, content)]) notebook = new_notebook(cells=cells, metadata={'language': 'python', 'kernelspec': kernelspec}) nbformat.write(notebook, filename)
def add_book_info(): for nb_name in iter_notebooks(): nb_file = os.path.join(NOTEBOOK_DIR, nb_name) nb = nbformat.read(nb_file, as_version=4) is_comment = lambda cell: cell.source.startswith(BOOK_COMMENT) if is_comment(nb.cells[0]): print('- amending comment for {0}'.format(nb_name)) nb.cells[0].source = BOOK_INFO else: print('- inserting comment for {0}'.format(nb_name)) nb.cells.insert(0, new_markdown_cell(BOOK_INFO)) nbformat.write(nb, nb_file)
def cells(): yield new_markdown_cell('<small>*Notebook auto-generated from ' '[``{0}``]({1})*</small>\n\n' '# Altair Example: {2}\n\n' '{3}\n\n'.format(full_filename, full_filepath, title, description)) yield new_markdown_cell('## Load Dataset\n' 'The data comes in the form of a Pandas ' 'Dataframe:') yield new_code_cell('from altair import load_dataset\n' 'data = load_dataset("{0}")\n' 'data.head()'.format(dataset)) yield new_markdown_cell('## Define Altair Specification') yield new_code_cell('from altair import * # Import the altair API\n\n' 'chart = {0}'.format(chart.to_altair(data='data'))) yield new_markdown_cell('IPython rich display will invoke Vega-Lite:') yield new_code_cell('chart') yield new_markdown_cell('## Output Vega-Lite Specification') yield new_markdown_cell('Generate JSON dict, leaving data out:') yield new_code_cell('chart.to_dict(data=False)')
offset = 0 for cell in nb.cells: if cell["cell_type"] == "code": if cell["source"] == '%jsroot on': offset = -1 else: cells_new.append(new_code_cell( source=cell.source, metadata=cell.metadata, outputs=[], # print cell.execution_count execution_count=cell.execution_count+offset)) # print cell.execution_count+offset elif cell["cell_type"] == "markdown": cells_new.append(new_markdown_cell( source=cell.source, metadata=cell.metadata)) else: cells_new.append(new_raw_cell( source=cell.source, metadata=cell.metadata)) # print cell.cell_type nb_new = new_notebook(cells=cells_new, metadata=nb.metadata, nbformat=nb.nbformat, nbformat_minor=nb.nbformat_minor ) with codecs.open(outfilename, encoding='utf-8', mode='w') as out:
def create_markdown_cell(block): """Create a markdown cell from a block.""" kwargs = {'cell_type': block['type'], 'source': block['content']} markdown_cell = nbbase.new_markdown_cell(**kwargs) return markdown_cell