File size: 4,551 Bytes
d1ceb73 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 |
"""Python API for composing notebook elements
The Python representation of a notebook is a nested structure of
dictionary subclasses that support attribute access.
The functions in this module are merely helpers to build the structs
in the right form.
"""
# Copyright (c) IPython Development Team.
# Distributed under the terms of the Modified BSD License.
from __future__ import annotations
from nbformat.corpus.words import generate_corpus_id as random_cell_id
from nbformat.notebooknode import NotebookNode
# Change the nbformat_minor and nbformat_schema variables when incrementing the
# nbformat version
# current major version
nbformat = 4
# current minor version
nbformat_minor = 5
# schema files for (major, minor) version tuples. (None, None) means the current version
nbformat_schema = {
(None, None): "nbformat.v4.schema.json",
(4, 0): "nbformat.v4.0.schema.json",
(4, 1): "nbformat.v4.1.schema.json",
(4, 2): "nbformat.v4.2.schema.json",
(4, 3): "nbformat.v4.3.schema.json",
(4, 4): "nbformat.v4.4.schema.json",
(4, 5): "nbformat.v4.5.schema.json",
}
def validate(node, ref=None):
"""validate a v4 node"""
from nbformat import validate as validate_orig
return validate_orig(node, ref=ref, version=nbformat)
def new_output(output_type, data=None, **kwargs):
"""Create a new output, to go in the ``cell.outputs`` list of a code cell."""
output = NotebookNode(output_type=output_type)
# populate defaults:
if output_type == "stream":
output.name = "stdout"
output.text = ""
elif output_type == "display_data":
output.metadata = NotebookNode()
output.data = NotebookNode()
elif output_type == "execute_result":
output.metadata = NotebookNode()
output.data = NotebookNode()
output.execution_count = None
elif output_type == "error":
output.ename = "NotImplementedError"
output.evalue = ""
output.traceback = []
# load from args:
output.update(kwargs)
if data is not None:
output.data = data
# validate
validate(output, output_type)
return output
def output_from_msg(msg):
"""Create a NotebookNode for an output from a kernel's IOPub message.
Returns
-------
NotebookNode: the output as a notebook node.
Raises
------
ValueError: if the message is not an output message.
"""
msg_type = msg["header"]["msg_type"]
content = msg["content"]
if msg_type == "execute_result":
return new_output(
output_type=msg_type,
metadata=content["metadata"],
data=content["data"],
execution_count=content["execution_count"],
)
if msg_type == "stream":
return new_output(
output_type=msg_type,
name=content["name"],
text=content["text"],
)
if msg_type == "display_data":
return new_output(
output_type=msg_type,
metadata=content["metadata"],
data=content["data"],
)
if msg_type == "error":
return new_output(
output_type=msg_type,
ename=content["ename"],
evalue=content["evalue"],
traceback=content["traceback"],
)
raise ValueError("Unrecognized output msg type: %r" % msg_type)
def new_code_cell(source="", **kwargs):
"""Create a new code cell"""
cell = NotebookNode(
id=random_cell_id(),
cell_type="code",
metadata=NotebookNode(),
execution_count=None,
source=source,
outputs=[],
)
cell.update(kwargs)
validate(cell, "code_cell")
return cell
def new_markdown_cell(source="", **kwargs):
"""Create a new markdown cell"""
cell = NotebookNode(
id=random_cell_id(),
cell_type="markdown",
source=source,
metadata=NotebookNode(),
)
cell.update(kwargs)
validate(cell, "markdown_cell")
return cell
def new_raw_cell(source="", **kwargs):
"""Create a new raw cell"""
cell = NotebookNode(
id=random_cell_id(),
cell_type="raw",
source=source,
metadata=NotebookNode(),
)
cell.update(kwargs)
validate(cell, "raw_cell")
return cell
def new_notebook(**kwargs):
"""Create a new notebook"""
nb = NotebookNode(
nbformat=nbformat,
nbformat_minor=nbformat_minor,
metadata=NotebookNode(),
cells=[],
)
nb.update(kwargs)
validate(nb)
return nb
|