def run_nb_test(nb_filename, output_fname):
"""test run"""
print(f'(1) Run notebook: {nb_filename}')
ye_notebook = nbformat.read(nb_filename, as_version=4)
client = NotebookClient(ye_notebook,
timeout=600,
kernel_name='python3',
resources={'metadata': {
'path': '.'
}})
client.execute()
if not os.path.isdir('test_output'):
os.makedirs('test_output')
output_file = f'test_output/{output_fname}'
nbformat.write(ye_notebook, output_file)
print(f'(2) file written: {output_file}')
ye_notebook2 = nbformat.read(output_file, as_version=4)
# 2. Instantiate the exporter. We use the `classic` template for now; we'll get into more details
# later about how to customize the exporter further.
html_exporter = HTMLExporter()
html_exporter.template_name = 'classic'
# 3. Process the notebook we loaded earlier
(body, resources) = html_exporter.from_notebook_node(ye_notebook)
html_filename = f'{output_file}.html'
open(html_filename, 'w').write(body)
print(f'file written: {html_filename}')
def run_notebook(nb_path, tmp_path, env=None, kernel=None, allow_errors=False):
"""Execute a Jupyter notebook via :mod:`nbclient` and collect output.
Parameters
----------
nb_path : path-like
The notebook file to execute.
tmp_path : path-like
A directory in which to create temporary output.
env : dict-like, optional
Execution environment for ``nbconvert``.
If not supplied, :obj:`os.environ` is used.
kernel : str, optional
Jupyter kernel to use. Default: 'python2' or 'python3', matching the
current Python version.
allow_errors : bool, optional
Whether to pass the ``--allow-errors`` option to ``nbconvert``. If
:obj:`True`, the execution always succeeds, and cell output contains
exception information.
Returns
-------
nb : :class:`nbformat.NotebookNode`
Parsed and executed notebook.
errors : list
Any execution errors.
"""
import nbformat
from nbclient import NotebookClient
# Workaround for https://github.com/jupyter/nbclient/issues/85
if (sys.version_info[0] == 3 and sys.version_info[1] >= 8
and sys.platform.startswith("win")):
import asyncio
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
# Read the notebook
with open(nb_path, encoding="utf-8") as f:
nb = nbformat.read(f, as_version=4)
# Create a client and use it to execute the notebook
client = NotebookClient(nb,
timeout=60,
kernel_name=kernel
or f"python{sys.version_info[0]}",
allow_errors=allow_errors,
resources=dict(metadata=dict(path=tmp_path)))
# Execute the notebook.
# `env` is passed from nbclient to jupyter_client.launcher.launch_kernel()
client.execute(env=env or os.environ.copy())
# Retrieve error information from cells
errors = [
output for cell in nb.cells if "outputs" in cell
for output in cell["outputs"] if output.output_type == "error"
]
return nb, errors
def test_notebook_3d_backend(renderer_notebook, brain_gc):
"""Test executing a notebook that should not fail."""
import nbformat
from nbclient import NotebookClient
notebook_filename = os.path.join(PATH, "test.ipynb")
with open(notebook_filename) as f:
nb = nbformat.read(f, as_version=4)
client = NotebookClient(nb)
client.execute()
def main(notebook_paths):
"""
Executes Jupyter Notebooks from the command line.
Expects one or more file paths input as arguments.
Errors are raised and printed to the console.
Example:
$ python run.py ./src/notebooks.ipynb
"""
for path_string in notebook_paths:
click.echo(f"🐍🗒️ {path_string}")
# Get the file name
name = path_string.replace(".ipynb", "")
# Get its parent directory so we can add it to the $PATH
path = pathlib.Path(path_string).parent.absolute()
# Set the intput and output file paths
input_path = f"{name}.ipynb"
output_path = f"{name}-output.ipynb"
# Open up the notebook we're going to run
with open(input_path) as f:
nb = nbformat.read(f, as_version=4)
# Configure nbclient to run the notebook
client = NotebookClient(
# What we want it to run
nb,
timeout=600,
kernel_name='python3',
# We want to allow errors so it doesn't fail silently
allow_errors=False,
force_raise_errors=True,
# Here's where the path gets set
resources={'metadata': {
'path': path
}})
try:
# Run it
client.execute()
except CellExecutionError:
# If there's an error, print it to the terminal.
msg = f"Error executing {input_path}.\n See {output_path} for the traceback."
click.echo(msg)
# And then raise it too
raise
finally:
# Once all that's done, write out the output notebook to the filesystem
with open(output_path, mode='w', encoding='utf-8') as f:
nbformat.write(nb, f)
def _execute_notebook(path):
"""
Private method to execute the provided notebook and handle errors.
"""
with open(path) as f:
nb = nbformat.read(f, as_version=4)
client = NotebookClient(nb,
timeout=600,
kernel_name='python3',
resources={'metadata': {
'path': 'notebooks/'
}})
try:
client.execute()
except CellExecutionError:
out = None
msg = f'Error executing the notebook "{path}".\n\n'
msg += f'See notebook "{path}" for the traceback.'
print(msg)
raise
finally:
with open(path, mode='w', encoding='utf-8') as f:
nbformat.write(nb, f)
]
if os.environ.get("PR", "") != "":
notebooks = [
nb for nb in notebooks if not any(avoid in nb for avoid in run_on_master_only)
]
os.chdir("workshop")
for notebook in notebooks:
print(f"Loading {notebook}")
nb = nbformat.read(notebook, as_version=4)
for cell in nb.cells:
if cell.get("cell_type", "") == "code" and "no-execute" in cell.get(
"metadata", {}
).get("tags", []):
cell["cell_type"] = "markdown"
client = NotebookClient(
nb,
timeout=600,
resources={"metadata": {"path": os.path.dirname(notebook)}},
)
try:
client.execute()
nbformat.write(nb, notebook)
except CellExecutionError:
msg = 'Error executing the notebook "%s".\n\n' % notebook
print(msg)
raise
def compile_tutorial(tutorial_name, force_recompile=False):
print('- Compiling tutorial ' + tutorial_name + '...')
notebook_path = 'tutorial_notebooks/' + tutorial_name + '/' + tutorial_name + '.ipynb'
export_path = 'tutorials/' + tutorial_name + '/' + tutorial_name
thumb_dest = os.path.dirname(export_path) + '/thumb.png'
if not os.path.exists(os.path.dirname(export_path)):
os.makedirs(os.path.dirname(export_path))
# Read in notebook
notebook = nbformat.read(notebook_path, 4)
# Scrape title, description and thumbnail
first_cell = notebook.cells[0]
title = first_cell.source.splitlines()[0]
if '#' in title:
title = title.replace('#', '').strip()
description = ''
for line in first_cell.source.splitlines()[1:]:
if line.strip():
description = line.strip()
break
if not description:
print(' Description could not be found in the notebook.')
if 'thumbnail_figure_index' in notebook.metadata:
thumbnail_figure_index = notebook.metadata['thumbnail_figure_index']
else:
thumbnail_figure_index = -1
if 'level' in notebook.metadata:
level = notebook.metadata['level'].capitalize()
elif 'difficulty' in notebook.metadata:
level = notebook.metadata['difficulty'].capitalize()
else:
level = 'Unknown'
# Check if the tutorial was already compiled.
if os.path.exists(export_path + '.rst'):
if os.path.getmtime(export_path +
'.rst') > os.path.getmtime(notebook_path):
if force_recompile:
print(' Already compiled. Recompiling anyway...')
else:
print(' Already compiled. Skipping...')
return title, level, description, thumb_dest.split('/', 1)[-1]
# Execute notebook if not already executed
already_executed = any(
c.get('outputs') or c.get('execution_count') for c in notebook.cells
if c.cell_type == 'code')
resources = {'metadata': {'path': os.path.dirname(notebook_path)}}
if not already_executed:
start = time.time()
additional_cell_1 = {
"cell_type":
"code",
"execution_count":
None,
"metadata": {},
"outputs": [],
"source":
r"%matplotlib inline" + '\n' +
r"%config InlineBackend.print_figure_kwargs = {'bbox_inches': None, 'figsize': (8, 6)}"
}
additional_cell_2 = {
"cell_type":
"code",
"execution_count":
None,
"metadata": {},
"outputs": [],
"source":
"import matplotlib as mpl\nmpl.rcParams['figure.figsize'] = (8, 6)\nmpl.rcParams['figure.dpi'] = 150\nmpl.rcParams['savefig.dpi'] = 150"
}
notebook.cells.insert(1, nbformat.from_dict(additional_cell_1))
notebook.cells.insert(2, nbformat.from_dict(additional_cell_2))
client = NotebookClient(nb=notebook,
resources=resources,
timeout=600,
kernel_name='python3')
try:
client.execute()
except CellExecutionError as err:
print(' Error while processing notebook:')
print(' ', err)
notebook.cells.pop(2)
notebook.cells.pop(1)
end = time.time()
print(' Compilation took %d seconds.' % (end - start))
else:
print(' Notebook was already executed.')
exporter = RSTExporter()
output, resources = exporter.from_notebook_node(notebook, resources)
writer = FilesWriter(build_directory=os.path.dirname(export_path))
writer.write(output,
resources,
notebook_name=os.path.basename(export_path))
pictures = sorted(resources['outputs'], key=output.find)
try:
thumbnail_source = pictures[thumbnail_figure_index]
# Read in thumbnail source image
img = Image.open(os.path.dirname(export_path) + '/' + thumbnail_source)
# Trim whitespace
bg = Image.new(img.mode, img.size, img.getpixel((0, 0)))
diff = ImageChops.difference(img, bg)
diff = ImageChops.add(diff, diff)
bbox = diff.getbbox()
if bbox:
img = img.crop(bbox)
# Resize image to have a width of 400px
img.thumbnail([400, 1000])
# Save thumbnail
img.save(thumb_dest)
except:
shutil.copyfile('_static/no_thumb.png', thumb_dest)
print(' Done!')
return title, level, description, thumb_dest.split('/', 1)[-1]