def run_code(source: tuple, kernel_name='python3'):
"""Run code blocks inside a jupyter kernel.
Args:
source (tuple): source code blocks
kernel_name: name of the kernel (form the kernel spec) to be created
"""
import IPython
if pkg_version.parse(IPython.__version__) < pkg_version.parse('7.6.0'):
raise RuntimeError("IPython version {} not supported."
" Kale requires at least version 7.6.0.".format(
IPython.__version__))
# new notebook
spec = get_kernel_spec(kernel_name)
notebook = nbformat.v4.new_notebook(
metadata={
'kernelspec': {
'display_name': spec.display_name,
'language': spec.language,
'name': kernel_name,
}
})
notebook.cells = [nbformat.v4.new_code_cell(s) for s in source]
# these parameters are passed to nbconvert.ExecutePreprocessor
jupyter_execute_kwargs = dict(timeout=-1,
allow_errors=True,
store_widget_state=True)
resources = {}
# cwd: If supplied, the kernel will run in this directory
# resources['metadata'] = {'path': cwd}
ep = ExecutePreprocessor(**jupyter_execute_kwargs)
km = ep.kernel_manager_class(kernel_name=kernel_name, config=ep.config)
# start_kernel supports several additional arguments via **kw
km.start_kernel(extra_arguments=ep.extra_arguments)
kc = km.client()
kc.start_channels()
try:
kc.wait_for_ready(timeout=60)
except RuntimeError:
kc.stop_channels()
raise
kc.allow_stdin = False
def signal_handler(_signal, _frame):
raise KaleKernelException()
# this signal is used by the thread in case an error message is received
# by the kernel. Running sys.exit() inside the thread would terminate
# just the thread itself, not the main process. Calling os._exit() can be
# dangerous as the process is killed instantly (files and connections are
# not closed, for example). With a signal we can capture the ExitCommand
# exception from the main process and exit gracefully.
signal.signal(signal.SIGUSR1, signal_handler)
# start separate thread in to capture and print stdout, stderr, errors.
# daemon mode will make the watcher thread die when the main one returns.
x = threading.Thread(target=capture_streams,
args=(
kc,
True,
),
daemon=True)
x.start()
try:
# start preprocessor: run each code cell and capture the output
ep.preprocess(notebook, resources, km=km)
except KaleKernelException:
# exit gracefully with error
sys.exit(-1)
# Give some time to the stream watcher thread to receive all messages from
# the kernel before shutting down.
time.sleep(1)
km.shutdown_kernel()
result = process_outputs(notebook.cells)
return result
