def get_kernel_location(kernel_name):
if kernel_exists(kernel_name):
manager = KernelSpecManager()
return manager.get_kernel_spec(kernel_name).resource_dir
else:
from jupyter_client.kernelspec import NoSuchKernel
raise NoSuchKernel(kernel_name)
def get_kernelspec(self, name):
"""Get a kernel specification dictionary given a kernel name
"""
ksm = KernelSpecManager()
kernelspec = ksm.get_kernel_spec(name).to_dict()
kernelspec['name'] = name
kernelspec.pop('argv')
return kernelspec
def _read_notebook(notebook_file):
notebook_data = notebook_file.read()
notebook = nbformat.reads(notebook_data, as_version=4)
km = KernelSpecManager()
print(km.get_kernel_spec("python3").to_dict())
ep = ExecutePreprocessor(timeout=600, kernel_name='python3')
ep.preprocess(notebook, {'metadata': {'path': tempfile.gettempdir()}})
return notebook
def test_kernelspec_installed(self):
"""Test that the jupyter kernelspec installations work, and that
all the examples can be installed as expected."""
manager = KernelSpecManager()
# Remove all kernelspecs first.
subprocess.check_call(["jupyter", "kernelspec", "remove", "-f",
"basic", "calculator", "stdin"])
# Check that kernelspec installation works, the kernel exists after
# it has been installed, and the executable file is found.
subprocess.check_call(["kernel-basic", "install"])
kernelspec = manager.get_kernel_spec("basic")
self.assertTrue(os.path.isfile(kernelspec.argv[0]))
subprocess.check_call(["kernel-calculator", "install"])
kernelspec = manager.get_kernel_spec("calculator")
self.assertTrue(os.path.isfile(kernelspec.argv[0]))
subprocess.check_call(["kernel-stdin", "install"])
kernelspec = manager.get_kernel_spec("stdin")
self.assertTrue(os.path.isfile(kernelspec.argv[0]))
def install_my_kernel_spec(user=True, prefix=None):
with TemporaryDirectory() as td:
os.chmod(td, 0o755) # Starts off as 700, not user readable
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, sort_keys=True)
print('Installing Jupyter kernel spec')
ksm = KernelSpecManager()
ksm.install_kernel_spec(td, 'elm', user=user, prefix=prefix)
install_dir = ksm.get_kernel_spec(kernel_name="elm").resource_dir
print("Installed to ", install_dir)
def __init__(self, settings, document_language):
"""Initializes available kernel names"""
self.__settings = settings
self.__doc_lang = document_language
spec_manager = KernelSpecManager()
kernel_names = spec_manager.find_kernel_specs()
self.__available_kernel_names_mappings = {}
for name in kernel_names:
spec = spec_manager.get_kernel_spec(name)
self.__available_kernel_names_mappings[spec.display_name] = name
self.__manager = MultiKernelManager()
self.__client_managers = {}
def __init__(self, settings, document_language):
"""Initializes available kernel names"""
self.__settings = settings
self.__doc_lang = document_language
spec_manager = KernelSpecManager()
kernel_names = spec_manager.find_kernel_specs()
self.__available_kernel_names_mappings = {}
for name in kernel_names:
spec = spec_manager.get_kernel_spec(name)
self.__available_kernel_names_mappings[spec.display_name] = name
self.__manager = MultiKernelManager()
self.__client_managers = {}
def install_my_kernel_spec(user=True, prefix=None):
if "python2" in sys.executable:
print("I think this needs python3")
with TemporaryDirectory() as td:
os.chmod(td, 0o755) # Starts off as 700, not user readable
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, sort_keys=True)
# TODO: Copy resources once they're specified
print('Installing IPython kernel spec of micropython')
k = KernelSpecManager()
k.install_kernel_spec(td,
'Micropython-upydevice',
user=user,
prefix=prefix)
h = k.get_kernel_spec("micropython-upydevice")
print("...into", h.resource_dir)
def get_notebook_kernel(kernel_name, kernel_spec_manager=None):
"""
return a `KernelSpec <https://ipython.org/ipython-doc/dev/api/generated/IPython.kernel.kernelspec.html>`_
@param kernel_spec_manager see `KernelSpecManager <http://jupyter-client.readthedocs.org/en/latest/api/kernelspec.html#jupyter_client.kernelspec.KernelSpecManager>`_
A KernelSpecManager to use for installation.
If none provided, a default instance will be created.
@param kernel_name kernel name
@return KernelSpec
The function only works with Jupyter>=4.0.
.. versionadded:: 1.3
"""
if kernel_spec_manager is None:
from jupyter_client.kernelspec import KernelSpecManager
kernel_spec_manager = KernelSpecManager()
return kernel_spec_manager.get_kernel_spec(kernel_name)
def get_notebook_kernel(kernel_name, kernel_spec_manager=None):
"""
Returns a `KernelSpec <https://ipython.org/ipython-doc/dev/api/
generated/IPython.kernel.kernelspec.html>`_.
@param kernel_spec_manager see `KernelSpecManager <http://jupyter-client.readthedocs.org/en/
latest/api/kernelspec.html#jupyter_client.kernelspec.KernelSpecManager>`_
A KernelSpecManager to use for installation.
If none provided, a default instance will be created.
@param kernel_name kernel name
@return KernelSpec
The function only works with *Jupyter>=4.0*.
"""
if kernel_spec_manager is None:
from jupyter_client.kernelspec import KernelSpecManager
kernel_spec_manager = KernelSpecManager()
return kernel_spec_manager.get_kernel_spec(kernel_name)
def _jupyter_kernel(args):
"""Make xonsh available as a Jupyter kernel."""
try:
from jupyter_client.kernelspec import KernelSpecManager, NoSuchKernel
except ImportError as e:
raise ImportError(
"Jupyter not found in current Python environment") from e
ksm = KernelSpecManager()
root = args.root
prefix = args.prefix if args.prefix else sys.prefix
user = args.user
spec = {
"argv": [
sys.executable,
"-m",
"xonsh.jupyter_kernel",
"-f",
"{connection_file}",
],
"display_name":
"Xonsh",
"language":
"xonsh",
"codemirror_mode":
"shell",
}
if root and prefix:
# os.path.join isn't used since prefix is probably absolute
prefix = root + prefix
try:
old_jup_kernel = ksm.get_kernel_spec(XONSH_JUPYTER_KERNEL)
if not old_jup_kernel.resource_dir.startswith(prefix):
print("Removing existing Jupyter kernel found at {0}".format(
old_jup_kernel.resource_dir))
ksm.remove_kernel_spec(XONSH_JUPYTER_KERNEL)
except NoSuchKernel:
pass
if sys.platform == "win32":
# Ensure that conda-build detects the hard coded prefix
spec["argv"][0] = spec["argv"][0].replace(os.sep, os.altsep)
prefix = prefix.replace(os.sep, os.altsep)
with tempfile.TemporaryDirectory() as d:
os.chmod(d, 0o755) # Starts off as 700, not user readable
with open(os.path.join(d, "kernel.json"), "w") as f:
json.dump(spec, f, sort_keys=True)
print("Installing Jupyter kernel spec:")
print(" root: {0!r}".format(root))
if user:
print(" as user: {0}".format(user))
elif root and prefix:
print(" combined prefix {0!r}".format(prefix))
else:
print(" prefix: {0!r}".format(prefix))
ksm.install_kernel_spec(d,
XONSH_JUPYTER_KERNEL,
user=user,
prefix=(None if user else prefix))
return 0
def get_kernelspec(name):
ksm = KernelSpecManager()
kernelspec = ksm.get_kernel_spec(name).to_dict()
kernelspec['name'] = name
kernelspec.pop('argv')
return kernelspec
import unittest
import nbformat
import pytest
from jupyter_client.kernelspec import KernelSpecManager, NoSuchKernel
from nbconvert.preprocessors import ExecutePreprocessor
from nbconvert.preprocessors.execute import CellExecutionError
from popmon import resources
kernel_name = "python3"
# check if jupyter python3 kernel can be opened. if kernel not found, skip unit tests below.
try:
km = KernelSpecManager()
km.get_kernel_spec(kernel_name)
kernel_found = True
except NoSuchKernel:
kernel_found = False
class NotebookTest(unittest.TestCase):
"""Unit test notebook"""
def run_notebook(self, notebook):
""" Test notebook """
# load notebook
with open(notebook) as f:
nb = nbformat.read(f, as_version=4)
def _jupyter_kernel(
user=False,
prefix=None,
root=None,
):
"""Generate xonsh kernel for jupyter.
Parameters
----------
user : -u, --user
Install kernel spec in user config directory.
prefix : -p, --prefix
Installation prefix for bin, lib, etc.
root : -r, --root
Install relative to this alternate root directory.
"""
try:
from jupyter_client.kernelspec import KernelSpecManager, NoSuchKernel
except ImportError as e:
raise ImportError("Jupyter not found in current Python environment") from e
ksm = KernelSpecManager()
prefix = prefix or sys.prefix
spec = {
"argv": [
sys.executable,
"-m",
"xonsh.jupyter_kernel",
"-f",
"{connection_file}",
],
"display_name": "Xonsh",
"language": "xonsh",
"codemirror_mode": "shell",
}
if root and prefix:
# os.path.join isn't used since prefix is probably absolute
prefix = root + prefix
try:
old_jup_kernel = ksm.get_kernel_spec(XONSH_JUPYTER_KERNEL)
if not old_jup_kernel.resource_dir.startswith(prefix):
print(
"Removing existing Jupyter kernel found at {}".format(
old_jup_kernel.resource_dir
)
)
ksm.remove_kernel_spec(XONSH_JUPYTER_KERNEL)
except NoSuchKernel:
pass
if sys.platform == "win32":
# Ensure that conda-build detects the hard coded prefix
spec["argv"][0] = spec["argv"][0].replace(os.sep, os.altsep)
prefix = prefix.replace(os.sep, os.altsep)
with tempfile.TemporaryDirectory() as d:
os.chmod(d, 0o755) # Starts off as 700, not user readable
with open(os.path.join(d, "kernel.json"), "w") as f:
json.dump(spec, f, sort_keys=True)
print("Installing Jupyter kernel spec:")
print(f" root: {root!r}")
if user:
print(f" as user: {user}")
elif root and prefix:
print(f" combined prefix {prefix!r}")
else:
print(f" prefix: {prefix!r}")
ksm.install_kernel_spec(
d, XONSH_JUPYTER_KERNEL, user=user, prefix=(None if user else prefix)
)
return 0
